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

muhamed_directory/other/orlando/interfaces.py

+from abc import ABC, abstractmethod
+
+# Definition des Interfaces für den StringCalculator
+class IStringCalculator(ABC):
+    @abstractmethod
+    def add(self, numbers: str) -> int:
+        """
+        Addiert beliebig viele Zahlen, die durch Kommas getrennt sind.
+        Leere oder nur aus Leerzeichen bestehende Einträge werden ignoriert.
+
+        :param numbers: String mit Zahlen (z.B. "1,2,3")
+        :return: Summe der Zahlen als int
+        """
+        pass
+
+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

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

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

muhamed_directory/other/orlando/test_string_calculator.py

+# Testfälle add(numbers: str) -> int – StringCalculator
+
+# 1. Leerer String
+# Eingabe: "" → Erwartete Ausgabe: 0
+
+# 2. Einzelne Zahl
+# Eingabe: "1" → Erwartete Ausgabe: 1
+
+# 3. Zwei Zahlen, getrennt durch Komma
+# Eingabe: "1,2" → Erwartete Ausgabe: 3
+
+# 4. Mehr als zwei Zahlen (beliebig viele erlaubt)
+# Eingabe: "1,2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2,3,4,5" → Erwartete Ausgabe: 15
+
+# 5. Leere Einträge ignorieren
+# Eingabe: "1,,2" → Erwartete Ausgabe: 3
+# Eingabe: "1, ,2" → Erwartete Ausgabe: 3
+# Eingabe: ",,1,,2,,," → Erwartete Ausgabe: 3
+
+# 6. Zeilenumbrüche als Trennzeichen erlauben
+# Eingabe: "1\n2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2\n3" → Erwartete Ausgabe: 6
+# Eingabe: "1\n2\n3" → Erwartete Ausgabe: 6
+
+# 8. Negative Zahlen → Exception mit allen negativen Werten
+# Eingabe: "1,-2" → Exception mit Message "negatives not allowed: -2"
+# Eingabe: "-1,-2,3" → Exception mit Message "negatives not allowed: -1, -2"
+
+# 9. Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+# Eingabe: "//;\n1;2" → 3
+# Eingabe: "//|\n4|5|6" → 15
+# Eingabe: "//_\n7_8_9" → 24
+
+# 10. Zahlen größer als 1000 ignorieren
+# Eingabe: "2,1001" → 2
+# Eingabe: "1000,1" → 1001 (1000 zählt noch mit)
+# Eingabe: "1234,1001,3" → 3
+
+# 11. Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+# Eingabe: "//[***]\n1***2***3" → 6
+# Eingabe: "//[abc]\n4abc5abc6" → 15
+# Eingabe: "//[+]\n1+2+3" → 6
+
+import unittest
+from src.string_calculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+    def setUp(self):
+        # Vor jedem Test wird eine Instanz des Calculators erstellt
+        self.calc = StringCalculator()
+
+    def test_add_empty_string(self):
+        # Leerer String → 0
+        self.assertEqual(self.calc.add(""), 0)
+
+    def test_add_single_number(self):
+        # Ein einzelner Wert → int
+        self.assertEqual(self.calc.add("1"), 1)
+
+    def test_add_two_numbers(self):
+        # Zwei Zahlen → Summe
+        self.assertEqual(self.calc.add("1,2"), 3)
+
+    def test_add_multiple_numbers(self):
+        # Mehr als zwei Zahlen → Summe
+        self.assertEqual(self.calc.add("1,2,3"), 6)
+        self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
+
+    def test_add_ignores_empty_entries(self):
+        # Leere Einträge ignorieren → Summe
+        self.assertEqual(self.calc.add("1,,2"), 3)
+        self.assertEqual(self.calc.add("1, ,2"), 3)
+        self.assertEqual(self.calc.add(",,1,,2,,,"), 3)
+
+    def test_add_with_newlines_between_numbers(self):
+        # Zeilenumbrüche als Trennzeichen erlauben → Summe
+        self.assertEqual(self.calc.add("1\n2,3"), 6)
+        self.assertEqual(self.calc.add("1,2\n3"), 6)
+        self.assertEqual(self.calc.add("1\n2\n3"), 6)
+
+    def test_add_raises_exception_on_negative_number(self):
+        # Negative Zahlen → Exception mit allen negativen Werten
+        with self.assertRaises(ValueError) as context:
+            self.calc.add("1,-2")
+        self.assertIn("negatives not allowed: -2", str(context.exception))
+
+    def test_add_raises_exception_on_multiple_negatives(self):
+        # Negative Zahlen → Exception mit allen negativen Werten
+        with self.assertRaises(ValueError) as context:
+            self.calc.add("-1,-2,3")
+        self.assertIn("negatives not allowed: -1, -2", str(context.exception))
+
+    def test_add_with_custom_delimiter(self):
+        # Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+        self.assertEqual(self.calc.add("//;\n1;2"), 3)
+        self.assertEqual(self.calc.add("//|\n4|5|6"), 15)
+        self.assertEqual(self.calc.add("//_\n7_8_9"), 24)
+
+    def test_add_ignores_numbers_greater_than_1000(self):
+        # Zahlen größer als 1000 ignorieren
+        self.assertEqual(self.calc.add("2,1001"), 2)
+        self.assertEqual(self.calc.add("1000,1"), 1001)
+        self.assertEqual(self.calc.add("1234,1001,3"), 3)
+
+    def test_add_with_multi_char_delimiter(self):
+        # Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+        self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
+        self.assertEqual(self.calc.add("//[abc]\n4abc5abc6"), 15)
+        self.assertEqual(self.calc.add("//[+]\n1+2+3"), 6)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

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

muhamed_directory/other/wasili/Testszenarios.txt

+Convert int to str (römische Zahlen BSP):
+-Bei Eingabe des integers 1 liefert die Funktion I
+-Bei Eingabe des integers 21 liefert die Funktion XXI
+-Bei Eingabe eines leeren integers soll "Fehler: Bitte Zahl eingeben" rauskommen
+-Bei Eingabe eines strings "Hello" soll "Fehler: Bitte Zahl eingeben" rauskommen
+-Bei Eingabe eines des integers -5 soll "Integer muss größer als 0 sein" rauskommen
+-Bei Eingabe des integers 1000 liefert die Funktion "M"

report.md

+| Name                    | Interface break | Failed Testcases | Begründung                                                                                                                                         |
+|-------------------------|-----------------|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------|
+| Alma                    | yes             | all              | `TypeError`: Methode `convert()` fehlt der erwartete Parameter `n`. Interface nicht eingehalten.                                                  |
+| ich vs Alma Tests       | no              | none             | Einziger definierter Test in `test2converter.py` wurde bestanden.                                                                                  |
+| Daniel                  | yes             | all              | Die Tests rufen Converter.convert() als statische Methode auf, aber die convert-Methode aus Skript 1 ist eine Instanzmethode, die eine Objektinstanz (self) benötigt. Dieser falsche Aufruf verursacht bei jedem der 7 Tests einen TypeError, weil das erwartete self-Argument fehlt. |
+| Ich vs Daniel Tests     | no              | none             | 
+| Hatice                    | yes             | all              | TypeError: RomanNumber.convert() missing 1 required positional argument: 'n'                                                  |
+| ich vs Hatice Tests       | no              | 1             | FAIL: test_inivalid_numbers (__main__.TestRomanConverter.test_inivalid_numbers)                                                                                  |
+| Lasse                    | yes             | all              | TypeError: RomanNumerals.to_roman() missing 1 required positional argument: 'num'                                                  |
+| Wasili                    | yes             | all              | TypeError: RomanNumber.convert_int_to_str() missing 1 required positional argument: 'n'                                                  |
+| ich vs wasili Tests       | no              | 2            | TypeError: '>=' not supported between instances of 'str' and 'int')                                                                                  |
+| Orlando                    | yes             | all              | nicht umsätzbar                                                  |
\ No newline at end of file