From 1901316ab95ad1eecd60bfaa419b75c74fcad7e0 Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sat, 5 Apr 2025 09:39:13 +0200
Subject: [PATCH 1/5] Download Implementierung von WeishauptOrlando
---
Other/WeishauptOrlando_1/src/Count_ED.py | 8 +++
.../WeishauptOrlando_1/src/RomanConverter.py | 50 +++++++++++++++++
Other/WeishauptOrlando_1/src/__init__.py | 53 +++++++++++++++++++
Other/WeishauptOrlando_1/src/calculator.py | 44 +++++++++++++++
Other/WeishauptOrlando_1/src/interfaces.py | 17 ++++++
5 files changed, 172 insertions(+)
create mode 100644 Other/WeishauptOrlando_1/src/Count_ED.py
create mode 100644 Other/WeishauptOrlando_1/src/RomanConverter.py
create mode 100644 Other/WeishauptOrlando_1/src/__init__.py
create mode 100644 Other/WeishauptOrlando_1/src/calculator.py
create mode 100644 Other/WeishauptOrlando_1/src/interfaces.py
diff --git a/Other/WeishauptOrlando_1/src/Count_ED.py b/Other/WeishauptOrlando_1/src/Count_ED.py
new file mode 100644
index 0000000..3b6973a
--- /dev/null
+++ b/Other/WeishauptOrlando_1/src/Count_ED.py
@@ -0,0 +1,8 @@
+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")
diff --git a/Other/WeishauptOrlando_1/src/RomanConverter.py b/Other/WeishauptOrlando_1/src/RomanConverter.py
new file mode 100644
index 0000000..e45a5e2
--- /dev/null
+++ b/Other/WeishauptOrlando_1/src/RomanConverter.py
@@ -0,0 +1,50 @@
+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
diff --git a/Other/WeishauptOrlando_1/src/__init__.py b/Other/WeishauptOrlando_1/src/__init__.py
new file mode 100644
index 0000000..1b733ab
--- /dev/null
+++ b/Other/WeishauptOrlando_1/src/__init__.py
@@ -0,0 +1,53 @@
+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
diff --git a/Other/WeishauptOrlando_1/src/calculator.py b/Other/WeishauptOrlando_1/src/calculator.py
new file mode 100644
index 0000000..f4b4785
--- /dev/null
+++ b/Other/WeishauptOrlando_1/src/calculator.py
@@ -0,0 +1,44 @@
+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)}")
diff --git a/Other/WeishauptOrlando_1/src/interfaces.py b/Other/WeishauptOrlando_1/src/interfaces.py
new file mode 100644
index 0000000..e9c300f
--- /dev/null
+++ b/Other/WeishauptOrlando_1/src/interfaces.py
@@ -0,0 +1,17 @@
+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
--
GitLab
From 8aa0654955e867f241635ed432f49b1240d848dd Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sat, 5 Apr 2025 09:51:29 +0200
Subject: [PATCH 2/5] Meine Implementierung converter.py
---
Other/WeishauptOrlando_1/converter.py | 49 +++++++++++++++++++++++++++
1 file changed, 49 insertions(+)
create mode 100644 Other/WeishauptOrlando_1/converter.py
diff --git a/Other/WeishauptOrlando_1/converter.py b/Other/WeishauptOrlando_1/converter.py
new file mode 100644
index 0000000..0ef9bd0
--- /dev/null
+++ b/Other/WeishauptOrlando_1/converter.py
@@ -0,0 +1,49 @@
+#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()
--
GitLab
From e35403e8c17be433269fedbeb66cccc26503801a Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sat, 5 Apr 2025 09:53:58 +0200
Subject: [PATCH 3/5] =?UTF-8?q?Implementierung=20von=20WeishauptOrlando=20?=
=?UTF-8?q?mit=20meinen=20Testf=C3=A4llen=20getestet?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Other/WeishauptOrlando_1/my_converter.py | 36 ++++++++++++++++++++++++
1 file changed, 36 insertions(+)
create mode 100644 Other/WeishauptOrlando_1/my_converter.py
diff --git a/Other/WeishauptOrlando_1/my_converter.py b/Other/WeishauptOrlando_1/my_converter.py
new file mode 100644
index 0000000..ced88c3
--- /dev/null
+++ b/Other/WeishauptOrlando_1/my_converter.py
@@ -0,0 +1,36 @@
+#Umsetzungen von WeishauptOrlando auf meine Testfälle
+
+import unittest
+
+from src.RomanConverter import RomanConverter as RomanNumber
+from src.interfaces import IRomanConverter
+
+
+class TestRomanConverter(unittest.TestCase):
+ def setUp(self):
+ self.converter = RomanNumber()
+
+ def test_implements_interface(self):
+ self.assertIsInstance(self.converter, IRomanConverter)
+
+ 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()
--
GitLab
From 71c47ff5f8a67c110f4e9585abc34d18af596e8d Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sat, 5 Apr 2025 09:55:15 +0200
Subject: [PATCH 4/5] =?UTF-8?q?Meine=20Implementierung=20mit=20WeishauptOr?=
=?UTF-8?q?lando=20Testf=C3=A4llen=20getestet?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Other/WeishauptOrlando_1/your_converter.py | 39 ++++++++++++++++++++++
1 file changed, 39 insertions(+)
create mode 100644 Other/WeishauptOrlando_1/your_converter.py
diff --git a/Other/WeishauptOrlando_1/your_converter.py b/Other/WeishauptOrlando_1/your_converter.py
new file mode 100644
index 0000000..593c8b7
--- /dev/null
+++ b/Other/WeishauptOrlando_1/your_converter.py
@@ -0,0 +1,39 @@
+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 converter import RomanNumber # Importiere die zu testende Klasse
+from converter import IRomanNumber
+
+class TestRomanConverter(unittest.TestCase):
+ def setUp(self):
+ self.converter = RomanNumber()
+
+ def test_implements_interface(self):
+ self.assertIsInstance(self.converter, IRomanNumber)
+
+ 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
--
GitLab
From 45f38653446c81addf7735829506a16d7a27c896 Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sat, 5 Apr 2025 09:57:33 +0200
Subject: [PATCH 5/5] Download Tests von WeishauptOrlando
---
.../WeishauptOrlando_1/tests/TestCount_ED.py | 34 ++++++
Other/WeishauptOrlando_1/tests/__init__.py | 0
.../tests/test_calculator.py | 103 ++++++++++++++++++
Other/WeishauptOrlando_1/tests/test_roman.py | 66 +++++++++++
4 files changed, 203 insertions(+)
create mode 100644 Other/WeishauptOrlando_1/tests/TestCount_ED.py
create mode 100644 Other/WeishauptOrlando_1/tests/__init__.py
create mode 100644 Other/WeishauptOrlando_1/tests/test_calculator.py
create mode 100644 Other/WeishauptOrlando_1/tests/test_roman.py
diff --git a/Other/WeishauptOrlando_1/tests/TestCount_ED.py b/Other/WeishauptOrlando_1/tests/TestCount_ED.py
new file mode 100644
index 0000000..152bccd
--- /dev/null
+++ b/Other/WeishauptOrlando_1/tests/TestCount_ED.py
@@ -0,0 +1,34 @@
+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
diff --git a/Other/WeishauptOrlando_1/tests/__init__.py b/Other/WeishauptOrlando_1/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/Other/WeishauptOrlando_1/tests/test_calculator.py b/Other/WeishauptOrlando_1/tests/test_calculator.py
new file mode 100644
index 0000000..a0c7931
--- /dev/null
+++ b/Other/WeishauptOrlando_1/tests/test_calculator.py
@@ -0,0 +1,103 @@
+# 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
diff --git a/Other/WeishauptOrlando_1/tests/test_roman.py b/Other/WeishauptOrlando_1/tests/test_roman.py
new file mode 100644
index 0000000..30cbabf
--- /dev/null
+++ b/Other/WeishauptOrlando_1/tests/test_roman.py
@@ -0,0 +1,66 @@
+# 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
--
GitLab