Project structure defined and first test integrated

converter.py → Project_tests/converter.py

@@ -27,13 +27,14 @@
 
 import unittest
 from abc import ABC, abstractmethod
+from other.AliciMuhamed.Test_Converter_Römische_Zahlen import ConverterMomo as MomoCalc
 
 class IConverter(ABC):
     @abstractmethod
     def convert(self, num: int) -> str:
         pass
 
-class Converter(IConverter):
+class DanisConverter(IConverter):
     def convert(self, num: int) -> str:
 
         '''Sicherstellen, dass nur eine ganze Zahl eingegeben wurde.'''
@@ -69,7 +70,7 @@ class Converter(IConverter):
 
 class TestConverter(unittest.TestCase):
     def setUp(self):
-        self.c = Converter()
+        self.c = MomoCalc
 
     def test_convertOne(self):
         res = self.c.convert(1)

Project_tests/other/AliciMuhamed/Test_Converter_Römische_Zahlen.py

+#Test_Converter_Römische_Zahlen
+
+import unittest
+
+class ConverterMomo():
+    def convert(n: int) -> str:
+        roman_numerals = {
+            1000: "M", 900: "CM", 500: "D", 400: "CD",
+            100: "C", 90: "XC", 50: "L", 40: "XL",
+            10: "X", 9: "IX", 5: "V", 4: "IV", 1: "I"
+        }
+        result = ""
+        for value in sorted(roman_numerals.keys(), reverse=True): #Schleife, die über die Schlüssel (die Dezimalzahlen) des roman_numerals-Dictionaries iteriert und in absteigender reienfolge zurück gibt durch value nimmt  in jeder Iteration den Wert des nächsten sortierten Schlüssels an
+            while n >= value: #Dies startet eine while-Schleife, die so lange ausgeführt wird, wie der Wert von n größer oder gleich dem aktuellen value (der Dezimalzahl) ist
+                result += roman_numerals[value] #fügt die entsprechende römische Ziffer (den Wert aus dem roman_numerals-Dictionary) zur result-Zeichenkette hinzu.
+                n -= value # aktuelle value - n
+        return result
+
+class TestRomanConverter(unittest.TestCase):
+    def test_1(self):
+        self.assertEqual(ConverterMomo.convert(1), "I")  # Erwartet "I" für 1
+
+    def test_10(self):
+        self.assertEqual(ConverterMomo.convert(10), "X")  # Erwartet "X" für 10
+    def test_21(self):
+        self.assertEqual(ConverterMomo.convert(21), "XXI")  # Erwartet "XXI" für 21
+    def test_50(self):
+        self.assertEqual(ConverterMomo.convert(50), "L")  # Erwartet "L" für 50
+    def test_100(self):
+        self.assertEqual(ConverterMomo.convert(100), "C")  # Erwartet "C" für 100
+    def test_1000(self):
+        self.assertEqual(ConverterMomo.convert(1000), "M")  # Erwartet "M" für 1000
+    def test_1999(self):
+        self.assertEqual(ConverterMomo.convert(1999), "MCMXCIX") #Erwartet "MCMXCIX" für 1999
+ 
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/BerishaAlma/test2 converter.py

+import unittest
+from abc import ABC, abstractmethod
+
+class IRomanNumber(ABC):
+    @abstractmethod
+    def convert(self, n:int) -> str:
+        pass
+
+class RomanNumber(IRomanNumber):
+    def convert(self, n: int) -> str:
+        roman_numerals = {
+            3: "III",  6: "VI", 8: "VIII",
+            12: "XII",  17: "XVII", 29: "XXIX",
+            34: "XXXIV",  55: "LV", 101: "CI",
+            501: "DI",  1003: "MIII"
+        }
+        return roman_numerals.get(n, "")
+
+class TestRomanConverter(unittest.TestCase):
+    def setUp(self):
+        self.converter = RomanNumber()
+
+    def test_single_value(self):
+        self.assertEqual(self.converter.convert(3), "III")
+        self.assertEqual(self.converter.convert(6), "VI")
+        self.assertEqual(self.converter.convert(8), "VIII")
+        self.assertEqual(self.converter.convert(12), "XII")
+        self.assertEqual(self.converter.convert(17), "XVII")
+        self.assertEqual(self.converter.convert(29), "XXIX")
+        self.assertEqual(self.converter.convert(34), "XXXIV")
+        self.assertEqual(self.converter.convert(55), "LV")
+        self.assertEqual(self.converter.convert(101), "CI")
+        self.assertEqual(self.converter.convert(501), "DI")
+        self.assertEqual(self.converter.convert(1003), "MIII")
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/GotsisWasilios/TDD_Converter.py

+import unittest
+from abc import ABC, abstractmethod
+
+#Interface für Counter
+class IRomanNumber(ABC):
+    @abstractmethod
+    def convert_int_to_str(self, n: int) -> str:
+        pass
+
+# Implementierung Converter Klasse
+class RomanNumber(IRomanNumber):
+    def convert_int_to_str(self, n: int) -> str:
+
+        #Eingabe anders als int
+        if not isinstance(n, int):
+            return "Fehler: Bitte Zahl eingeben"
+        
+        #Int Eingabe kleiner gleich 0
+        if n <= 0:
+            return "Integer muss größer als 0 sein"
+
+        # Bekannte Werte umwandeln
+        roman_convert = {1: "I", 21: "XXI", 1000: "M"}
+        return roman_convert.get(n)
+        
+# Testklasse (TestConverter)
+class TestRomanNumber (unittest.TestCase):
+    def setUp(self):
+        self.r = RomanNumber()
+
+    def test_convert_1(self):
+        self.assertEqual(self.r.convert_int_to_str(1), "I")
+
+    def test_convert_21(self):
+        self.assertEqual(self.r.convert_int_to_str(21), "XXI")
+
+    def test_convert_empty(self):
+        self.assertEqual(self.r.convert_int_to_str(None), "Fehler: Bitte Zahl eingeben")
+
+    def test_convert_string(self):
+        self.assertEqual(self.r.convert_int_to_str("Hello"), "Fehler: Bitte Zahl eingeben")
+
+    def test_convert_downzero(self):
+        self.assertEqual(self.r.convert_int_to_str(-5), "Integer muss größer als 0 sein")
+
+    def test_convert_downzero(self):
+        self.assertEqual(self.r.convert_int_to_str(1000), "M")
+
+if __name__ == "__main__":
+    unittest.main()
+

Project_tests/other/PikkemaatLasse/calculator.py

+#Test1: Addition 2 positiver Zaheln (2+5) erwartetes Ergebnis 8
+#Test2: Addition negativer und positiver Zahl (-1+1) erwartetes Ergebnis 0
+#Test3: Addition (0+0), erwartetes Ergebnis 0
+#Test4: Addition von 2 Dezimalzahlen (2,5+3,5), erwartetes Ergebnis 6
+
+from abc import ABC, abstractmethod
+class ICalculator(ABC):
+    @abstractmethod
+    def add(self, a: float, b: float) -> float:
+        pass
+
+class Calculator(ICalculator):
+    def add(self, a: float, b: float) -> float:
+        return a + b
+
+class TestCalculator:
+    def __init__(self, calculator: ICalculator):
+        self.calculator = calculator
+    def test_add(self):
+        assert self.calculator.add(2,3) == 5, "Fehler falls nicht 5"
+        assert self.calculator.add(-1,1) == 0, "Fegler falls nich 0"
+        assert self.calculator.add(0,0) == 0, "Fehler falls nicht 0"
+        assert self.calculator.add(2.5,3.5) == 6, "Fehler falls nicht 5"
+        print("Test erfolgreich")
+
+if __name__ == "__main__":
+    calc = Calculator()
+    tester = TestCalculator(calc)
+    tester.test_add()

Project_tests/other/PikkemaatLasse/counter.py

+#Bei Eingabe des Strings "Decker" liefert die Funktion 3
+#Bei Eingabe eines leeren Stings soll 0 augegeben werden
+#Bei Eingabe des Strings "Hallo" ohne E und D soll 0 ausgegeben werden
+#Bei Eingabe von dem String "Der Esel" soll Groß-Kleinschreibung (Caseinsensitive) gezählt werden. das Ergebnis ist 4
+#Bei Eingabe des Buchstaben D oder E soll 1 ausgegeben werden
+
+from abc import ABC,abstractmethod
+import unittest
+
+class ICounter (ABC):
+    @abstractmethod
+    def count_ED(self,s):
+        pass
+
+class Counter (ICounter):
+    def count_ED(self, s):
+        s=s.upper()
+        return s.count("D")+s.count("E")
+        
+class TestCounter (unittest.TestCase):
+    def setUp(self):
+        self.c=Counter()
+    def test_count_ED_regular (self):
+        res=self.c.count_ED ("Decker")
+        self.assertEqual(res,3)
+    def test_count_ED_empty (self):
+        res=self.c.count_ED ("")
+        self.assertEqual(res,0)
+    def test_count_ED_wo (self):
+        '''Testet einen String ohne E und D'''
+        res=self.c.count_ED ("Hallo")
+        self.assertEqual(res,0)
+    def test_count_ED_case_insensitive (self):
+        '''Testet verschiedene Groß- und Kleinschreibungen'''
+        res=self.c.count_ED ("Der Esel")
+        self.assertEqual(res,4) 
+    def test_count_ED_single_letetr (self):
+        '''Testet Eingaben mit nur einem Buchstaben'''
+        res=self.c.count_ED ('D')
+        self.assertEqual(res,1) 
+        res=self.c.count_ED ('E')
+        self.assertEqual (res,1)
+        res=self.c.count_ED ('d')
+        self.assertEqual(res,1) 
+        res=self.c.count_ED ('e')
+        self.assertEqual (res,1)
+if __name__=="__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/PikkemaatLasse/interfaces.py

+from abc import ABC, abstractmethod
+
+class IRomanNumerals(ABC):
+    @abstractmethod
+    def to_roman(self, num):
+        pass
\ No newline at end of file

Project_tests/other/WeishauptOrlando/src/Count_ED.py

+from src.interfaces import ICounter
+
+
+class Counter(ICounter):
+    def count_ed(self, s: str) -> int:
+        """Zählt die Anzahl der Buchstaben 'E' und 'D' in einem String (Case-Insensitive)."""
+        s = s.upper()
+        return s.count("D") + s.count("E")

Project_tests/other/WeishauptOrlando/src/RomanConverter.py

+from src.interfaces import IRomanConverter
+
+
+def int_to_roman(num: int) -> str:
+    """Konvertiert eine Dezimalzahl in eine römische Zahl."""
+    val = [
+        1000, 900, 500, 400,
+        100, 90, 50, 40,
+        10, 9, 5, 4,
+        1
+    ]
+    syb = [
+        "M", "CM", "D", "CD",
+        "C", "XC", "L", "XL",
+        "X", "IX", "V", "IV",
+        "I"
+    ]
+    roman_num = ''
+    i = 0
+    while num > 0:
+        for _ in range(num // val[i]):
+            roman_num += syb[i]
+            num -= val[i]
+        i += 1
+    return roman_num
+
+
+class RomanConverter(IRomanConverter):
+    def roman_to_int(self, s: str) -> int:
+        """Konvertiert eine römische Zahl (String) in eine Dezimalzahl."""
+        roman_values = {
+            'I': 1, 'V': 5, 'X': 10, 'L': 50,
+            'C': 100, 'D': 500, 'M': 1000
+        }
+
+        total = 0
+        prev_value = 0
+
+        # Iteriere über die Zeichen der römischen Zahl von rechts nach links
+        for char in reversed(s.upper()):
+            value = roman_values.get(char)
+            if value is None:
+                raise ValueError(f"Ungültiges Zeichen '{char}' in der römischen Zahl.")
+            if value < prev_value:
+                total -= value
+            else:
+                total += value
+            prev_value = value
+
+        return total

Project_tests/other/WeishauptOrlando/src/__init__.py

+from src.calculator import Calculator
+from src.Count_ED import Counter
+from src.RomanConverter import RomanConverter, int_to_roman
+
+if __name__ == "__main__":
+    # Erstelle eine Instanz der Calculator-Klasse
+    calc = Calculator()
+
+    # Eine Liste von Test-Ausdrücken, die überprüft werden sollen
+    test_expressions = [
+        "2+3",      # Einfacher Additionstest
+        "10-4/2",   # Test mit Division und Subtraktion
+        "(3+5)*2",  # Komplexerer Ausdruck mit Klammern
+        "3++5",     # Ungültiger Ausdruck (doppelte Operatoren)
+        "3--5",     # Ungültiger Ausdruck (doppelte Operatoren)
+        "10*/2",    # Ungültiger Ausdruck (Operatorenkombinationen)
+        "5/0",      # Division durch Null (Fehler)
+        "(3+5))",   # Ungültiger Ausdruck (zu viele Klammern)
+        "abc",      # Ungültiger Ausdruck (nur Buchstaben)
+        "-3*-3"     # Gültiger Ausdruck mit Vorzeichen
+    ]
+
+    # Schleife, um alle Test-Ausdrücke zu durchlaufen
+    for expr in test_expressions:
+        try:
+            # Versuche, den Ausdruck zu berechnen und gebe das Ergebnis aus
+            print(f"Eingabe: '{expr}' → Ausgabe: {calc.calculate(expr)}")
+        except Exception as e:
+            # Wenn ein Fehler auftritt, gebe die Fehlermeldung aus
+            print(f"Eingabe: '{expr}' → Fehler: {e}")
+print("______________________________________________________________")
+if __name__ == "__main__":
+    counter = Counter()
+    test_strings = ["Decker", "", "Hallo", "Der Esel", "D", "E", "d", "e"]
+
+    for string in test_strings:
+        print(f"Eingabe: '{string}' → Ausgabe: {counter.count_ed(string)}")
+
+print("______________________________________________________________")
+
+if __name__ == "__main__":
+    converter = RomanConverter()
+    # Test römische Zahl in Dezimalzahl umwandeln
+    print("Test römische Zahl in Dezimalzahl umwandeln")
+    print(converter.roman_to_int("MCMXCIV"))  # Ausgabe: 1994
+    print(converter.roman_to_int("XIV"))  # Ausgabe: 14
+    print(converter.roman_to_int("CDXLIV"))  # Ausgabe: 444
+
+    # Test Dezimalzahl in römische Zahl umwandeln
+    print("Test Dezimalzahl in römische Zahl umwand")
+    print(int_to_roman(1994))  # Ausgabe: MCMXCIV
+    print(int_to_roman(14))    # Ausgabe: XIV
+    print(int_to_roman(444))   # Ausgabe: CDXLIV
\ No newline at end of file

Project_tests/other/WeishauptOrlando/src/calculator.py

+import re
+from src.interfaces import ICalculator
+
+
+class Calculator(ICalculator):
+    """Ein Taschenrechner, der mathematische Ausdrücke berechnet."""
+
+    def calculate(self, expression: str) -> float:
+        """Berechnet einen mathematischen Ausdruck als String und überprüft auf ungültige Eingaben."""
+        try:
+            # Entfernt überflüssige Leerzeichen
+            expression = expression.replace(" ", "")
+
+            # Nur erlaubte Zeichen (Zahlen, Operatoren, Klammern) und Zahlen mit Vorzeichen
+            if not re.match(r'^[0-9+\-*/().]+$', expression):
+                raise ValueError("Ungültige Zeichen im Ausdruck.")
+
+            # Überprüfung auf doppelte Operatoren, aber keine Vorzeichen wie -* oder -+
+            # Hier wird jetzt auch sichergestellt, dass -3*-3 gültig bleibt
+            if re.search(r'(?<!\d)[+\-*/]{2,}', expression):  # Erfasst auch doppelte Operatoren wie ++, --, **, etc.
+                raise SyntaxError("Ungültige doppelte Operatoren im Ausdruck.")
+
+            # Sicherstellen, dass Klammern ausgeglichen sind
+            if expression.count("(") != expression.count(")"):
+                raise ValueError("Fehlende oder zu viele Klammern.")
+
+            # Sicherstellen, dass der Ausdruck nicht mit einem Operator beginnt oder endet,
+            # aber das Minuszeichen als Teil der Zahl akzeptiert wird
+            if re.match(r'^[*/]', expression) or re.match(r'[*/]$', expression):  # Weitere Kontrolle
+                raise ValueError("Der Ausdruck darf nicht mit einem Operator beginnen oder enden.")
+
+            # Evaluierung des mathematischen Ausdrucks mit eval()
+            result = eval(expression, {"__builtins__": None}, {})
+
+            # Sicherstellen, dass das Ergebnis numerisch ist
+            if isinstance(result, (int, float)):
+                return float(result)
+            else:
+                raise ValueError("Ungültiger Ausdruck.")
+
+        except ZeroDivisionError:
+            raise ZeroDivisionError("Division durch Null ist nicht erlaubt.")
+        except (SyntaxError, TypeError, NameError) as e:
+            raise ValueError(f"Ungültiger mathematischer Ausdruck: {str(e)}")

Project_tests/other/WeishauptOrlando/src/interfaces.py

+from abc import ABC, abstractmethod
+
+class ICounter(ABC):
+    @abstractmethod
+    def count_ed(self, s: str) -> int:
+        """Zählt die Buchstaben 'E' und 'D' in einem String (Case-Insensitive)."""
+        pass
+class IRomanConverter(ABC):
+    @abstractmethod
+    def roman_to_int(self, s: str) -> int:
+        """Konvertiert eine römische Zahl (String) in eine Dezimalzahl."""
+        pass
+
+class ICalculator(ABC):
+    @abstractmethod
+    def calculate(self, expression: str) -> float:
+        pass
\ No newline at end of file

Project_tests/other/WeishauptOrlando/tests/TestCount_ED.py

+import unittest
+import sys
+import os
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+from src.Count_ED import Counter
+
+class TestCounter(unittest.TestCase):
+    def setUp(self):
+        self.c = Counter()
+
+    def test_count_ed_regular(self):
+        self.assertEqual(self.c.count_ed("Decker"), 3)
+
+    def test_count_ed_empty(self):
+        self.assertEqual(self.c.count_ed(""), 0)
+
+    def test_count_ed_wo(self):
+        """Testet einen String ohne E und D"""
+        self.assertEqual(self.c.count_ed("Hallo"), 0)
+
+    def test_count_ed_case_insensitive(self):
+        """Testet verschiedene Groß- und Kleinschreibungen"""
+        self.assertEqual(self.c.count_ed("Der Esel"), 4)
+
+    def test_count_ED_single_letter(self):
+        """Testet Eingaben mit nur einem Buchstaben"""
+        self.assertEqual(self.c.count_ed('D'), 1)
+        self.assertEqual(self.c.count_ed('E'), 1)
+        self.assertEqual(self.c.count_ed('d'), 1)
+        self.assertEqual(self.c.count_ed('e'), 1)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/WeishauptOrlando/tests/test_calculator.py

+# Testfälle für calculate(), Eingabe: str, Ausgabe: float/int
+
+# 1️⃣ Additionstests
+# Eingabe: "1+1" → Erwartete Ausgabe: 2
+# Eingabe: "10+20" → Erwartete Ausgabe: 30
+# Eingabe: "0+5" → Erwartete Ausgabe: 5
+# Eingabe: "-3+7" → Erwartete Ausgabe: 4
+# Eingabe: "2.5+2.5" → Erwartete Ausgabe: 5.0
+
+# 2️⃣ Subtraktionstests
+# Eingabe: "5-3" → Erwartete Ausgabe: 2
+# Eingabe: "10-20" → Erwartete Ausgabe: -10
+# Eingabe: "0-5" → Erwartete Ausgabe: -5
+# Eingabe: "-3-7" → Erwartete Ausgabe: -10
+# Eingabe: "2.5-1.5" → Erwartete Ausgabe: 1.0
+
+# 3️⃣ Multiplikationstests
+# Eingabe: "2*3" → Erwartete Ausgabe: 6
+# Eingabe: "10*0" → Erwartete Ausgabe: 0
+# Eingabe: "-2*5" → Erwartete Ausgabe: -10
+# Eingabe: "3.5*2" → Erwartete Ausgabe: 7.0
+# Eingabe: "-3*-3" → Erwartete Ausgabe: 9
+
+# 4️⃣ Divisionstests
+# Eingabe: "10/2" → Erwartete Ausgabe: 5
+# Eingabe: "5/2" → Erwartete Ausgabe: 2.5
+# Eingabe: "-6/3" → Erwartete Ausgabe: -2
+# Eingabe: "7.5/2.5" → Erwartete Ausgabe: 3.0
+# Eingabe: "5/0" → Erwartete Ausgabe: ZeroDivisionError (Fehlermeldung)
+
+# 5️⃣ Komplexe Berechnungen
+# Eingabe: "3+5*2" → Erwartete Ausgabe: 13 (Multiplikation vor Addition)
+# Eingabe: "(3+5)*2" → Erwartete Ausgabe: 16 (Klammer zuerst)
+# Eingabe: "10-4/2" → Erwartete Ausgabe: 8 (Division vor Subtraktion)
+# Eingabe: "3+(2*5)-8/4" → Erwartete Ausgabe: 10 (Mehrere Operatoren)
+
+# 6️⃣ Ungültige Eingaben
+# Eingabe: "3++5" → Erwartete Ausgabe: SyntaxError (Fehlermeldung)
+# Eingabe: "10*/2" → Erwartete Ausgabe: SyntaxError (Fehlermeldung)
+# Eingabe: "abc" → Erwartete Ausgabe: ValueError (Fehlermeldung)
+
+
+import unittest
+from src.calculator import Calculator
+
+class TestCalculator(unittest.TestCase):
+    def setUp(self):
+        self.calc = Calculator()
+
+    # Addition
+    def test_addition(self):
+        self.assertEqual(self.calc.calculate("1+1"), 2)
+        self.assertEqual(self.calc.calculate("10+20"), 30)
+        self.assertEqual(self.calc.calculate("0+5"), 5)
+        self.assertEqual(self.calc.calculate("-3+7"), 4)
+        self.assertEqual(self.calc.calculate("2.5+2.5"), 5.0)
+
+    # Subtraktion
+    def test_subtraction(self):
+        self.assertEqual(self.calc.calculate("5-3"), 2)
+        self.assertEqual(self.calc.calculate("10-20"), -10)
+        self.assertEqual(self.calc.calculate("0-5"), -5)
+        self.assertEqual(self.calc.calculate("-3-7"), -10)
+        self.assertEqual(self.calc.calculate("2.5-1.5"), 1.0)
+
+    # Multiplikation
+    def test_multiplication(self):
+        self.assertEqual(self.calc.calculate("2*3"), 6)
+        self.assertEqual(self.calc.calculate("10*0"), 0)
+        self.assertEqual(self.calc.calculate("-2*5"), -10)
+        self.assertEqual(self.calc.calculate("3.5*2"), 7.0)
+        self.assertEqual(self.calc.calculate("-3*-3"), 9)
+
+    # Division
+    def test_division(self):
+        self.assertEqual(self.calc.calculate("10/2"), 5)
+        self.assertEqual(self.calc.calculate("5/2"), 2.5)
+        self.assertEqual(self.calc.calculate("-6/3"), -2)
+        self.assertEqual(self.calc.calculate("7.5/2.5"), 3.0)
+
+    # Division durch Null
+    def test_division_by_zero(self):
+        with self.assertRaises(ZeroDivisionError):
+            self.calc.calculate("5/0")
+
+    # Komplexe Berechnungen
+    def test_complex_expressions(self):
+        self.assertEqual(self.calc.calculate("3+5*2"), 13)  # Punkt-vor-Strich beachten
+        self.assertEqual(self.calc.calculate("(3+5)*2"), 16)  # Klammer zuerst
+        self.assertEqual(self.calc.calculate("10-4/2"), 8)  # Division vor Subtraktion
+        self.assertEqual(self.calc.calculate("3+(2*5)-8/4"), 11.0)  #  11
+
+    # Ungültige Eingaben
+    def test_invalid_expressions(self):
+        with self.assertRaises(ValueError):
+            self.calc.calculate("3++5")
+        with self.assertRaises(ValueError):
+            self.calc.calculate("10*/2")
+        with self.assertRaises(ValueError):
+            self.calc.calculate("abc")
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/WeishauptOrlando/tests/test_roman.py

+# Testfälle roman_to_int, str -> int
+
+# 1. Einzelne römische Ziffern
+# Eingabe: "I" → Erwartete Ausgabe: 1
+# Eingabe: "V" → Erwartete Ausgabe: 5
+# Eingabe: "X" → Erwartete Ausgabe: 10
+# Eingabe: "L" → Erwartete Ausgabe: 50
+# Eingabe: "C" → Erwartete Ausgabe: 100
+# Eingabe: "D" → Erwartete Ausgabe: 500
+# Eingabe: "M" → Erwartete Ausgabe: 1000
+
+#2. Mehrere gleiche Ziffern hintereinander (einfache Addition)
+# Eingabe: "II" → Erwartete Ausgabe: 2
+# Eingabe: "XX" → Erwartete Ausgabe: 20
+# Eingabe: "CC" → Erwartete Ausgabe: 200
+# Eingabe: "MM" → Erwartete Ausgabe: 2000
+
+#3. Subtraktive Notation
+# Eingabe: "IV" → Erwartete Ausgabe: 4
+# Eingabe: "IX" → Erwartete Ausgabe: 9
+# Eingabe: "XL" → Erwartete Ausgabe: 40
+# Eingabe: "XC" → Erwartete Ausgabe: 90
+# Eingabe: "CD" → Erwartete Ausgabe: 400
+# Eingabe: "CM" → Erwartete Ausgabe: 900
+
+#4. Komplexe Zahlen
+# Eingabe: "MCMXCIV" → Erwartete Ausgabe: 1994
+#Eingabe: "XIV" → Erwartete Ausgabe: 14
+#Eingabe: "CDXLIV" → Erwartete Ausgabe: 444
+
+
+import sys
+import os
+import unittest
+
+# Füge das src-Verzeichnis zum Python-Pfad hinzu
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+
+from src.RomanConverter import RomanConverter  # Importiere die zu testende Klasse
+
+class TestRomanConverter(unittest.TestCase):
+    def setUp(self):
+        self.converter = RomanConverter()
+
+    def test_single_digits(self):
+        self.assertEqual(self.converter.roman_to_int("I"), 1)
+        self.assertEqual(self.converter.roman_to_int("V"), 5)
+        self.assertEqual(self.converter.roman_to_int("X"), 10)
+
+    def test_multiple_digits(self):
+        self.assertEqual(self.converter.roman_to_int("II"), 2)
+        self.assertEqual(self.converter.roman_to_int("XX"), 20)
+        self.assertEqual(self.converter.roman_to_int("VI"), 6)
+
+    def test_subtractive_notation(self):
+        self.assertEqual(self.converter.roman_to_int("IV"), 4)
+        self.assertEqual(self.converter.roman_to_int("IX"), 9)
+        self.assertEqual(self.converter.roman_to_int("XL"), 40)
+        self.assertEqual(self.converter.roman_to_int("XC"), 90)
+
+    def test_complex_numbers(self):
+        self.assertEqual(self.converter.roman_to_int("MCMXCIV"), 1994)
+        self.assertEqual(self.converter.roman_to_int("CDXLIV"), 444)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

Project_tests/other/YildirimHatice/converter.py

+#Bei Eingabe von Zahlen, die in der Liste definiert sind, sollen römische Zhalen zurückgegeben werden.
+#Bei Eingabe von Zahlen, die nicht in der Liste definiert ist, soll ein "" ausgeben werden.
+
+import unittest
+from abc import ABC, abstractmethod
+
+class IRomanNumber(ABC):
+    @abstractmethod
+    def convert(self, n:int) -> str:
+        pass
+
+class RomanNumber(IRomanNumber):
+    def convert(self, n: int) -> str:
+        roman_numerals = {
+            1: "I",  2: "II", 3: "III", 
+            4: "IV",  5: "V", 9: "IX", 
+            21: "XXI",  50: "L", 100: "C",
+            500: "D",  1000: "M" 
+        }
+        return roman_numerals.get(n, "")
+
+class TestRomanConverter(unittest.TestCase):
+    def setUp(self):
+        self.converter = RomanNumber()
+
+    def test_single_value(self):
+        self.assertEqual(self.converter.convert(1), "I")
+        self.assertEqual(self.converter.convert(2), "II")
+        self.assertEqual(self.converter.convert(3), "III")
+        self.assertEqual(self.converter.convert(4), "IV")
+        self.assertEqual(self.converter.convert(5), "V")
+        self.assertEqual(self.converter.convert(9), "IX")
+        self.assertEqual(self.converter.convert(21), "XXI")
+        self.assertEqual(self.converter.convert(50), "L")
+        self.assertEqual(self.converter.convert(100), "C")
+        self.assertEqual(self.converter.convert(500), "D")
+        self.assertEqual(self.converter.convert(1000), "M")
+    
+    def test_inivalid_numbers(self):
+        self.assertEqual(self.converter.convert(6), "")
+        self.assertEqual(self.converter.convert(99), "")
+        self.assertEqual(self.converter.convert(-1), "")
+        
+
+
+
+
+if __name__ == "__main__":
+    unittest.main()

Project_tests/report.md

+| Name         | Interface break | Failed Testcases                                        |
+|--------------|-----------------|---------------------------------------------------------|
+| AliciMuhamed | yes (4)         | test_convertFloat test_convertNegative test_convertZero |
+|              |                 |                                                         |
+|              |                 |                                                         |
+|              |                 |                                                         |
+|              |                 |                                                         |
+|              |                 |                                                         |
+|              |                 |                                                         |
\ No newline at end of file