String Calculator.py

+#test no string
+#test add 1 string
+#test adding 2 strings
+import unittest
+
+class StringCalculator:
+    def add (self, numbers : str)-> int: #Erwartet Integer
+        if not numbers:
+            return 0
+        else:
+            number_list = numbers.split(',')#aufteilung der strings
+            if len(number_list) ==1:
+                return int(number_list[0])#bei einem string wird er in int umgewandelt
+            elif len(number_list)==2:
+                return int(number_list[0])+ int(number_list[1])#bei 2 strings wird beides in int verwandelt und die summe zurück gegeben(Position 1/0+Position 2/1)
+            return 0
+        
+    
+class TestStingCalculator(unittest.TestCase):
+    def test_empty_string(self):
+        calculator = StringCalculator()
+        self.assertEqual(calculator.add(""), 0) #leerer string + 0
+    def test_single_number(self):
+        calculator = StringCalculator()
+        self.assertEqual(calculator.add("5"),5) #eingabe von einem String
+    def test_multiple_numbers(self):
+        calculator=StringCalculator()
+        self.assertEqual(calculator.add("5,5"),10)#eingabe mehrere strings
+
+if __name__=='__main__':
+    unittest.main()
\ No newline at end of file

Test_Converter_Römische_Zahlen.py

 #Test_Converter_Römische_Zahlen
 
 import unittest
+from abc import ABC, abstractmethod
+#from muhamed_directory.other.alma.test2converter import RomanNumber as Alma
+#from muhamed_directory.other.daniel.converter import Converter as Dani
+#from muhamed_directory.other.hatice.converter import RomanNumber as Hati
+#from muhamed_directory.other.wasili.TDD_Converter import RomanNumber as was
+from muhamed_directory.other.orlando.RomanConverter import int_to_roman as Lando
 
-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 IStringCalculator(ABC):
+    @abstractmethod
+    def add(self, numbers: str) -> int:
+        pass
 
+class Converter(IStringCalculator):
+    @staticmethod
+    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):
+            while n >= value:
+                result += roman_numerals[value]
+                n -= value
+        return result
+
+    
 class TestRomanConverter(unittest.TestCase):
+    
+    def setUp(self):
+        self.Converter = Lando
+
     def test_1(self):
-        self.assertEqual(convert(1), "I")  # Erwartet "I" für 1
+        self.assertEqual(self.Converter.int_to_roman(1), "I")
 
     def test_10(self):
-        self.assertEqual(convert(10), "X")  # Erwartet "X" für 10
+        self.assertEqual(self.calculator.roman_to_int(10), "X")
+
     def test_21(self):
-        self.assertEqual(convert(21), "XXI")  # Erwartet "XXI" für 21
+        self.assertEqual(self.calculator.roman_to_int(21), "XXI")
+
     def test_50(self):
-        self.assertEqual(convert(50), "L")  # Erwartet "L" für 50
+        self.assertEqual(self.calculator.roman_to_int(50), "L")
+
     def test_100(self):
-        self.assertEqual(convert(100), "C")  # Erwartet "C" für 100
+        self.assertEqual(self.calculator.roman_to_int(100), "C")
+
     def test_1000(self):
-        self.assertEqual(convert(1000), "M")  # Erwartet "M" für 1000
+        self.assertEqual(self.calculator.roman_to_int(1000), "M")
+
     def test_1999(self):
-        self.assertEqual(convert(1999), "MCMXCIX") #Erwartet "MCMXCIX" für 1999
- 
+        self.assertEqual(self.calculator.roman_to_int(1999), "MCMXCIX")
+
 if __name__ == "__main__":
     unittest.main()
\ No newline at end of file

muhamed_directory/other/alma/import unittest.py

+import unittest
+from abc import ABC, abstractmethod
+
+#Interface für Counter
+class ICounter(ABC):
+    @abstractmethod
+    def count_ED(self, s):
+        pass
+
+# Implementierung Counter Klasse
+class Counter(ICounter):
+       def count_ED(self, s):
+           s = s.upper()
+           return s.count("D") + s.count("E")
+
+class TextCounter (unittest.TestCase):
+    def setUp(self):
+        self.c = Counter()
+
+    def test_count_ED_regular(self):
+        ergebnis = self.c.count_ED("Decker")
+        self.assertEqual(ergebnis, 3)
+
+    def test_count_ED_empty(self):
+        ergebnis = self.c.count_ED("")
+        self.assertEqual(ergebnis, 0)
+
+    def test_count_ED_wo(self):
+        '''Testet einen String ohne E und D'''
+        ergebnis = self.c.count_ED("HAllo")
+        self.assertEqual(ergebnis, 0)
+
+    def test_count_ED_insensitive(self):
+        '''Testet verschiedene Groß- und Kleinschreibung '''
+        ergebnis = self.c.count_ED("Der Esel")
+        self.assertEqual(ergebnis, 4)
+   
+    def test_count_ED_single_letter(self):
+        '''Testet Eingaben mit nur einem Buchstaben'''
+        ergebnis = self.c.count_ED("D")
+        self.assertEqual(ergebnis, 1)
+        ergebnis = self.c.count_ED("E")
+        self.assertEqual(ergebnis, 1)
+        ergebnis = self.c.count_ED("d")
+        self.assertEqual(ergebnis, 1)
+        ergebnis = self.c.count_ED("e")
+        self.assertEqual(ergebnis, 1)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

muhamed_directory/other/alma/test2converter.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

muhamed_directory/other/daniel/converter.py

+# Bei Eingabe der Zahl 1 soll "I" ausgegeben werden
+# Bei Eingabe der Zahl 2 soll "II" ausgegeben werden
+# Bei Eingabe der Zahl 3 soll "III" ausgegeben werden
+# Bei Eingabe der Zahl 4 soll "IV" ausgegeben werden
+# Bei Eingabe der Zahl 5 soll "V" ausgegeben werden
+# Bei Eingabe der Zahl 9 soll "IX" ausgegeben werden
+# Bei Eingabe der Zahl 10 soll "X" ausgegeben werden
+# Bei Eingabe der Zahl 21 soll "XXI" ausgegeben werden
+# Bei Eingabe der Zahl 50 soll "L" ausgegeben werden
+# Bei Eingabe der Zahl 100 soll "C" ausgegeben werden
+# Bei Eingabe der Zahl 500 soll "D" ausgegeben werden
+# Bei Eingabe der Zahl 1000 soll "M" ausgegeben werden
+# Bei Eingabe der Zahl 1111 soll "MCXI" ausgegeben werden
+# Bei Eingabe der Zahl 99 soll "XCIX" ausgegeben werden
+# Bei Eingabe der Zahl 0 soll "Es gibt keine römische Null" ausgegeben werden
+# Bei Eingabe der Zahl 40 soll "XL" ausgegeben werden
+# Bei Eingabe eines Strings soll "Bitte ganze Zahlen eingeben" ausgegeben werden -> geändert aufgrund der Aufgabenstellung
+# Bei Eingabe von Float-Werten (z.B. 4,3) soll "Bitte ganze Zahlen eingeben" ausgegeben werden.
+# Bei Eingabe von negativen Werten (z.B. -5) soll "Es sind nur positive Zahlen zum konvertieren erlaubt" ausgegeben werden
+# Bei Eingabe der Zahl 2025 soll "MMXXV" ausgegeben werden
+# Bei Eingabe von Zeichen wie ! soll "Bitte ganze Zahlen eingeben" ausgegeben werden
+# Bei Eingabe mehrerer Zahlen wie 4, 3 soll "Bitte nur eine ganze Zahl eingeben" augegeben werden
+# Bei Eingabe größerer Zahlen wie z.B. 4000 soll "MMMM" ausgegeben werden
+# Bei Eingabe der Zahl 30 soll "XXX" ausgegeben werden
+# Bei Eingabe der Zahl 90 soll "90" ausgegeben werden
+# Bei Eingabe eines leeren Strings soll "Bitte ganze Zahlen eingeben" ausgegeben werden
+
+import unittest
+from abc import ABC, abstractmethod
+
+class IConverter(ABC):
+    @abstractmethod
+    def convert(self, num: int) -> str:
+        pass
+
+class Converter(IConverter):
+    def convert(self, num: int) -> str:
+
+        '''Sicherstellen, dass nur eine ganze Zahl eingegeben wurde.'''
+        if isinstance(num, str) and len(num.split(',')) > 1: 
+            return 'Bitte nur eine ganze Zahl eingeben'
+        
+        roman_numbers = [(1000, 'M'), (500, 'D'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')]
+        
+        roman_str = ''
+
+        '''Wenn eine 0 eingegeben wird muss eine Exception folgen'''
+        if num == 0:
+            return "Es gibt keine römische Null"
+        
+
+        '''Sicherstellen, dass keine Zeichen oder Strings eingegeben werden'''
+        if isinstance(num, int):
+
+            '''Sicherstellen, dass keine negativen Zahlen eingegeben werden'''
+            if num < 0:
+                return "Es sind nur positive Zahlen zum konvertieren erlaubt"
+            
+            for value, numeral in roman_numbers:
+
+                while num >= value:
+                    roman_str += numeral
+                    num -= value
+
+            return roman_str
+        else: 
+            return "Bitte ganze Zahlen eingeben"
+
+
+class TestConverter(unittest.TestCase):
+    def setUp(self):
+        self.c = Converter()
+
+    def test_convertOne(self):
+        res = self.c.convert(1)
+        self.assertEqual(res, 'I')
+    
+    def test_convertTwo(self):
+        res = self.c.convert(2)
+        self.assertEqual(res, 'II')
+    
+    def test_convertThree(self):
+        res = self.c.convert(3)
+        self.assertEqual(res, 'III')
+
+    def test_convertFour(self):
+        res = self.c.convert(4)
+        self.assertEqual(res, 'IV')
+
+    def test_convertFive(self):
+        res = self.c.convert(5)
+        self.assertEqual(res, 'V')
+
+    def test_convertNine(self):
+        res = self.c.convert(9)
+        self.assertEqual(res, 'IX')
+
+    def test_convertTen(self):
+        res = self.c.convert(10)
+        self.assertEqual(res, 'X')
+
+    def test_convertTwentyTwo(self):
+        res = self.c.convert(21)
+        self.assertEqual(res, 'XXI')
+
+    def test_convertFifty(self):
+        res = self.c.convert(50)
+        self.assertEqual(res, 'L')
+
+    def test_convertHundred(self):
+        res = self.c.convert(100)
+        self.assertEqual(res, 'C')
+
+    def test_convertFiveHundred(self):
+        res = self.c.convert(500)
+        self.assertEqual(res, 'D')
+
+    def test_convertThousand(self):
+        res = self.c.convert(1000)
+        self.assertEqual(res, 'M')
+    
+    def test_convertFourDigit(self):
+        res = self.c.convert(1111)
+        self.assertEqual(res, 'MCXI')
+
+    def test_convertNintyNine(self):
+        res = self.c.convert(99)
+        self.assertEqual(res, 'XCIX')
+
+    def test_convertZero(self):
+        res = self.c.convert(0)
+        self.assertEqual(res, 'Es gibt keine römische Null')
+
+    def test_convertFourty(self):
+        res = self.c.convert(40)
+        self.assertEqual(res, 'XL')
+
+    def test_convertString(self):
+        res = self.c.convert('HUIHIN')
+        self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+    def test_convertFloat(self):
+        res = self.c.convert(4.3)
+        self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+    def test_convertNegative(self):
+        res = self.c.convert(-4)
+        self.assertEqual(res, "Es sind nur positive Zahlen zum konvertieren erlaubt")
+
+    def test_convertYear(self):
+        res = self.c.convert(2025)
+        self.assertEqual(res, "MMXXV")
+
+    def test_convertSign(self):
+        res = self.c.convert('!')
+        self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+    def test_convertMultipleNum(self):
+        res = self.c.convert('4, 3')
+        self.assertEqual(res, "Bitte nur eine ganze Zahl eingeben")
+
+    def test_convertHighNum(self):
+        res = self.c.convert(4000)
+        self.assertEqual(res, "MMMM")
+
+    def test_convertThirty(self):
+        res = self.c.convert(30)
+        self.assertEqual(res, "XXX")
+
+    def test_convertNinety(self):
+        res = self.c.convert(90)
+        self.assertEqual(res, "XC")
+
+    def test_convertEmpty(self):
+        res = self.c.convert('')
+        self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+    
+
+
+if __name__ == "__main__":
+    unittest.main()

muhamed_directory/other/hatice/calculator.py

+import unittest
+
+class Calculator:
+    def add(self, a, b):
+        return a + b
+
+class TestCalculator(unittest.TestCase):
+    def test_add(self):
+        c = Calculator()
+        self.assertEqual(c.add(2,3), 5)
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

muhamed_directory/other/hatice/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()

muhamed_directory/other/hatice/counter.py

+#Bei Einhabe des Strings "Decker" liefert die Funktion 3
+#Bei Eingabe eines leeren Strings soll 0 ausgegeben werden
+#Bei Eingabe des Strings "Hallo" ohne E und D soll 0 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):
+    #return s.count("e")+s.count("D")
+    pass
+
+class TestCounter (unittest.TestCase):
+    def test_count_ED_regular (self):
+        c=Counter()
+        res=c.count_ED ("Decker")
+        self.assertEqual(res,3)
+    def test_count_ED_empty (self):
+        c=Counter()
+        res=c.count_ED ("")
+        self.assertEqual(res,0)
+    def test_count_ED_wo (self):
+        '''Testet einen String ohne E und D'''
+        c=Counter()
+        res=c.count_ED ("Hallo")
+        self.assertEqual(res,0)
+    
+
+if __name__=="__main__":
+    unittest.main()

muhamed_directory/other/hatice/test.py

+#Meine Übung, um es zu verstehen!
+class Employee:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
\ No newline at end of file

muhamed_directory/other/lasse/Test.py

+print("Hello WORLD")
+print("test")
\ No newline at end of file

muhamed_directory/other/lasse/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()

muhamed_directory/other/lasse/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

muhamed_directory/other/lasse/interfaces.py

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

muhamed_directory/other/lasse/romannumerals.py

+from src.interfaces import IRomanNumerals
+
+
+class RomanNumerals(IRomanNumerals):
+    def to_roman(self, num):
+        if not isinstance(num, int):
+            raise ValueError("Eingabe muss eine ganze Zahl sein")
+        if num <= 0 or num >= 4000:
+            raise ValueError("Zahl muss zwischen 1 und 3999 liegen")
+
+        val = [
+            (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, numeral) in val:
+            while num >= value:
+                result += numeral
+                num -= value
+        return result
\ No newline at end of file

muhamed_directory/other/lasse/test_romannumerals.py

+# Basisfälle
+# Bei Eingabe der Zahl 1, erhalte ich das Ergebnis I
+# Bei Eingabe der Zahl 5, erhalte ich das Ergebnis V
+# Bei Eingabe der Zahl 10, erhalte ich das Ergebnis X
+# Bei Eingabe der Zahl 50, erhalte ich das Ergebnis L
+# Bei Eingabe der Zahl 100, erhalte ich das Ergebnis C
+# Bei Eingabe der Zahl 500, erhalte ich das Ergebnis D
+# Bei Eingabe der Zahl 1000, erhalte ich das Ergebnis M
+# Substraktionsregel
+# Bei Eingabe der Zahl 4, erhalte ich das Ergebnis IV
+# Bei Eingabe der Zahl 9, erhalte ich das Ergebnis IX
+# Bei Eingabe der Zahl 40, erhalte ich das Ergebnis XL
+# Bei Eingabe der Zahl 90, erhalte ich das Ergebnis XC
+# Bei Eingabe der Zahl 400, erhalte ich das Ergebnis CD
+# Bei Eingabe der Zahl 900, erhalte ich das Ergebnis CM
+# Additionsregel
+# Bei Eingabe der Zahl 2 erhalte ich das Ergebnis "II"
+# Bei Eingabe der Zahl 3 erhalte ich das Ergebnis "III"
+# Bei Eingabe der Zahl 6 erhalte ich das Ergebnis "VI"
+# Bei Eingabe der Zahl 8 erhalte ich das Ergebnis "VIII"
+# Bei Eingabe der Zahl 30 erhalte ich das Ergebnis "XXX"
+# Bei Eingabe der Zahl 80 erhalte ich das Ergebnis "LXXX"
+# Kombination aus Addition und Subtraktion
+# Bei Eingabe der Zahl 14 erhalte ich das Ergebnis "XIV"
+# Bei Eingabe der Zahl 19 erhalte ich das Ergebnis "XIX"
+# Bei Eingabe der Zahl 29 erhalte ich das Ergebnis "XXIX"
+# Bei Eingabe der Zahl 44 erhalte ich das Ergebnis "XLIV"
+# Bei Eingabe der Zahl 99 erhalte ich das Ergebnis "XCIX"
+# Bei Eingabe der Zahl 444 erhalte ich das Ergebnis "CDXLIV"
+# Bei Eingabe der Zahl 999 erhalte ich das Ergebnis "CMXCIX"
+# Größere Zahlen
+# Bei Eingabe der Zahl 1001 erhalte ich das Ergebnis "MI"
+# Bei Eingabe der Zahl 1987 erhalte ich das Ergebnis "MCMLXXXVII"
+# Bei Eingabe der Zahl 2023 erhalte ich das Ergebnis "MMXXIII"
+# Bei Eingabe der Zahl 3999 erhalte ich das Ergebnis "MMMCMXCIX"
+# Fehlerfälle
+# Bei Eingabe der Zahl 0 erhalte ich eine Fehlermeldung
+# Bei Eingabe der Zahl -1 erhalte ich eine Fehlermeldung
+# Bei Eingabe der Zahl 4000 erhalte ich eine Fehlermeldung
+# Bei Eingabe der Zeichenfolge "ABC" erhalte ich eine Fehlermeldung
+# Bei Eingabe von None erhalte ich eine Fehlermeldung
+# Bei Eingabe der Zahl 3.14 erhalte ich eine Fehlermeldung
+
+import unittest
+from src.romannumerals import RomanNumerals
+
+
+class TestRomanNumerals(unittest.TestCase):
+    def setUp(self):
+        self.converter = RomanNumerals()
+
+    def test_to_roman_basic(self):
+        self.assertEqual(self.converter.to_roman(1), "I")
+        self.assertEqual(self.converter.to_roman(5), "V")
+        self.assertEqual(self.converter.to_roman(10), "X")
+        self.assertEqual(self.converter.to_roman(50), "L")
+        self.assertEqual(self.converter.to_roman(100), "C")
+        self.assertEqual(self.converter.to_roman(500), "D")
+        self.assertEqual(self.converter.to_roman(1000), "M")
+
+    def test_to_roman_subtraction(self):
+        self.assertEqual(self.converter.to_roman(4), "IV")
+        self.assertEqual(self.converter.to_roman(9), "IX")
+        self.assertEqual(self.converter.to_roman(40), "XL")
+        self.assertEqual(self.converter.to_roman(90), "XC")
+        self.assertEqual(self.converter.to_roman(400), "CD")
+        self.assertEqual(self.converter.to_roman(900), "CM")
+
+    def test_to_roman_addition(self):
+        self.assertEqual(self.converter.to_roman(2), "II")
+        self.assertEqual(self.converter.to_roman(3), "III")
+        self.assertEqual(self.converter.to_roman(6), "VI")
+        self.assertEqual(self.converter.to_roman(8), "VIII")
+        self.assertEqual(self.converter.to_roman(30), "XXX")
+        self.assertEqual(self.converter.to_roman(80), "LXXX")
+
+    def test_to_roman_mixed(self):
+        self.assertEqual(self.converter.to_roman(14), "XIV")
+        self.assertEqual(self.converter.to_roman(19), "XIX")
+        self.assertEqual(self.converter.to_roman(29), "XXIX")
+        self.assertEqual(self.converter.to_roman(44), "XLIV")
+        self.assertEqual(self.converter.to_roman(99), "XCIX")
+        self.assertEqual(self.converter.to_roman(444), "CDXLIV")
+        self.assertEqual(self.converter.to_roman(999), "CMXCIX")
+
+    def test_to_roman_large_numbers(self):
+        self.assertEqual(self.converter.to_roman(1001), "MI")
+        self.assertEqual(self.converter.to_roman(1987), "MCMLXXXVII")
+        self.assertEqual(self.converter.to_roman(2023), "MMXXIII")
+        self.assertEqual(self.converter.to_roman(3999), "MMMCMXCIX")
+
+    def test_to_roman_invalid(self):
+        with self.assertRaises(ValueError):
+            self.converter.to_roman(0)
+        with self.assertRaises(ValueError):
+            self.converter.to_roman(-1)
+        with self.assertRaises(ValueError):
+            self.converter.to_roman(4000)
+        with self.assertRaises(ValueError):
+            self.converter.to_roman("ABC")
+        with self.assertRaises(ValueError):
+            self.converter.to_roman(None)
+        with self.assertRaises(ValueError):
+            self.converter.to_roman(3.14)
+
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

muhamed_directory/other/orlando/RomanConverter.py

+
+
+
+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 IRomanConverter(ABC):
+    @abstractmethod
+    def roman_to_int(self, s: str) -> int:
+        """Konvertiert eine römische Zahl (String) in eine Dezimalzahl."""
+        pass
+ 
+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