From a8e25165d883e59d8f2372b6317377c28a6bad52 Mon Sep 17 00:00:00 2001
From: DaniRafeh28 <daniel.rafeh@student.reutlingen-university.de>
Date: Tue, 1 Apr 2025 16:34:40 +0200
Subject: [PATCH] Project structure defined and first test integrated
---
converter.py => Project_tests/converter.py | 5 +-
.../Test_Converter_R\303\266mische_Zahlen.py" | 37 +++++++
...er_R\303\266mische_Zahlen.cpython-312.pyc" | Bin 0 -> 3004 bytes
.../other/BerishaAlma/test2 converter.py | 37 +++++++
.../other/GotsisWasilios/TDD_Converter.py | 51 +++++++++
.../other/PikkemaatLasse/calculator.py | 29 +++++
Project_tests/other/PikkemaatLasse/counter.py | 48 ++++++++
.../other/PikkemaatLasse/interfaces.py | 6 +
.../other/WeishauptOrlando/src/Count_ED.py | 8 ++
.../WeishauptOrlando/src/RomanConverter.py | 50 +++++++++
.../other/WeishauptOrlando/src/__init__.py | 53 +++++++++
.../other/WeishauptOrlando/src/calculator.py | 44 ++++++++
.../other/WeishauptOrlando/src/interfaces.py | 17 +++
.../WeishauptOrlando/tests/TestCount_ED.py | 34 ++++++
.../other/WeishauptOrlando/tests/__init__.py | 0
.../WeishauptOrlando/tests/test_calculator.py | 103 ++++++++++++++++++
.../WeishauptOrlando/tests/test_roman.py | 66 +++++++++++
.../other/YildirimHatice/converter.py | 49 +++++++++
Project_tests/report.md | 9 ++
__pycache__/calculator.cpython-312.pyc | Bin 3501 -> 0 bytes
20 files changed, 644 insertions(+), 2 deletions(-)
rename converter.py => Project_tests/converter.py (97%)
create mode 100644 "Project_tests/other/AliciMuhamed/Test_Converter_R\303\266mische_Zahlen.py"
create mode 100644 "Project_tests/other/AliciMuhamed/__pycache__/Test_Converter_R\303\266mische_Zahlen.cpython-312.pyc"
create mode 100644 Project_tests/other/BerishaAlma/test2 converter.py
create mode 100644 Project_tests/other/GotsisWasilios/TDD_Converter.py
create mode 100644 Project_tests/other/PikkemaatLasse/calculator.py
create mode 100644 Project_tests/other/PikkemaatLasse/counter.py
create mode 100644 Project_tests/other/PikkemaatLasse/interfaces.py
create mode 100644 Project_tests/other/WeishauptOrlando/src/Count_ED.py
create mode 100644 Project_tests/other/WeishauptOrlando/src/RomanConverter.py
create mode 100644 Project_tests/other/WeishauptOrlando/src/__init__.py
create mode 100644 Project_tests/other/WeishauptOrlando/src/calculator.py
create mode 100644 Project_tests/other/WeishauptOrlando/src/interfaces.py
create mode 100644 Project_tests/other/WeishauptOrlando/tests/TestCount_ED.py
create mode 100644 Project_tests/other/WeishauptOrlando/tests/__init__.py
create mode 100644 Project_tests/other/WeishauptOrlando/tests/test_calculator.py
create mode 100644 Project_tests/other/WeishauptOrlando/tests/test_roman.py
create mode 100644 Project_tests/other/YildirimHatice/converter.py
create mode 100644 Project_tests/report.md
delete mode 100644 __pycache__/calculator.cpython-312.pyc
diff --git a/converter.py b/Project_tests/converter.py
similarity index 97%
rename from converter.py
rename to Project_tests/converter.py
index 1d5eff4..fda5578 100644
--- a/converter.py
+++ b/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)
diff --git "a/Project_tests/other/AliciMuhamed/Test_Converter_R\303\266mische_Zahlen.py" "b/Project_tests/other/AliciMuhamed/Test_Converter_R\303\266mische_Zahlen.py"
new file mode 100644
index 0000000..d0e4fa8
--- /dev/null
+++ "b/Project_tests/other/AliciMuhamed/Test_Converter_R\303\266mische_Zahlen.py"
@@ -0,0 +1,37 @@
+#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
diff --git "a/Project_tests/other/AliciMuhamed/__pycache__/Test_Converter_R\303\266mische_Zahlen.cpython-312.pyc" "b/Project_tests/other/AliciMuhamed/__pycache__/Test_Converter_R\303\266mische_Zahlen.cpython-312.pyc"
new file mode 100644
index 0000000000000000000000000000000000000000..7c164150f5a7f5ebd46b767698d5214ee97e2653
GIT binary patch
literal 3004
zcmc&$O>7%Q6rR~#+Z#7donPWKh43T5K~0>bElv4r>J%DLyH)>WSw<`4**2Tl>vnb>
z8q1Z66hsa^7=ctDddM+VIOK%5bL4<R6vY~GK;nYM#jS(5^4{7`L#e|pjO1@-cHX>s
z-+OQ7`A476OQ3nS{<s<Q5b_&Nn$6W1)b7CG0bzvEG>H?5d_<VEM3}rL)g|K8`KG`(
zmrmxCrh=#an%t0-b%nX--z0>0Nd#n_)1S)WXst1&WRWh?pr?ZKXsYqm>6$0h24VUD
z^u#G6afwk~W|FSlP?)@=#9fO@&?S7~thu0bTj!B%CM&2Z++4SF+)U9uDm!3|Hr5_G
z8X090lbOO?%*{MZWo^vM4zYITV;v8DcPTr3SF(5a7wBAr-yV&-JedF6&ZeiP$tOn$
zxhoe)L7q<#V$u6;1*t#_asamGeXu6sTK)wXk){-<_q*>ORY*a)LV{gUK_fy6M+BXQ
zZd%Z=kYZs$FF<!e(3p^BVuD_W?z*5eL0{!}FwR&)*a4G`B0z<~ag{j2I06KOR4^8m
zHUx}(1)W?$j)GhbQsLn`xY5#sl5ksD@Fx?>yuN4!6^`PfgJ&~IQ!{fJohQ>4dfCdQ
zZQ)u-rgOT5+J>P0xdMaK>BKb)lqJqzN?bJcX>Kg&iAy|r$FOek?3_Mt4_(nSx&=WS
zI+?h&cj1_=r)JG;I(yU5KTTQ&M)sItn%RY<ZDdW|1U;Z3WotI<w-Q-<R_BSSw2?9*
zx!Gh!XNjw@pzUUbcKL_zGKQ6!)wOtXHm#c@w-$vbRZp6H@2(tX&q(958#q{>0o)_M
zcJ-E~SFH7(a%WHJwUzMd)v~|4q^xwW_N>49*rN=1mpiIn($%x<{-yUwDY`v4x-mGq
zIXL$H@$KF-%je2n-NoG3!)1S8X=Jr`V_<Z{KU#E`{hh^YUwMnP>LT4e#oRZ;Rhjfn
z(W*-PeapTY98ID@w@@|B1WuYJyqcEDvRoR+?V5HwmrOTSWW%(DY}uT@0lOX%j=|=y
zBVbS*zzABs086AQ9dh**C#nRx(!>sS^&Kdjg5Pdy=6~%ZeA;^pmq;A$At2sE5_d6p
z8RBl{0`xF9pvpXeZHsEKO>|*6E@STOy80hC6HUY0Rf{^O6v$ljT$neT-FS%znM3(!
z8l!8CJxpreM0j0DP>%8!L6-LbJd(wsqy<@NpF`)>edBnH3dPdXH!RdK<Ty^aF}bv{
zeBj^4kJOh?rF9hG9x1Es+iL%Y+W+wAc3@;9FtU1kGcdM3v8BH4c=jOa4uD16kAU}{
z9|zdW%TqT#lpknGECf#zskLIpHv{AA;Vt#lK{Kmh_6j)`o7s=q_*iRZ<74;+w~U#?
z?A(@m`k<NdelUw;f!dGRiG5;rA_PT;@JR%`{0EtEeRya)!gCW&Z6sVMf24KBg)rM%
z2FBV9OsrqoQYR0b8>SprTXJh_atq}L_aPU0X+L)MX5jdG>VHT(<0tq(C_IsHBo>~D
zJwJL4hLe+%`!Iynm;aNYv8A4I;uj5ic@SMXjPMo$mKS~s;XQ;85T+2q2p=MhAUv&W
zA)F#~!_UG}w?v*u)OG5Ko4O{SDAe^1f-^epOlvTmqIDIx5i4sZX_%UZRW@fDHU`rv
z3PQzThLcb#oO94xp`h?HW(f7&dP#nte+)8MKCH6<Rhd#+a}(<SOKGQlj|sre;9)vN
rOa0q{;f=uX4#8RV6{55+=YN(1Wu^1p`7a}%N4~fS{{xf($Iib2miujF
literal 0
HcmV?d00001
diff --git a/Project_tests/other/BerishaAlma/test2 converter.py b/Project_tests/other/BerishaAlma/test2 converter.py
new file mode 100644
index 0000000..2e04e94
--- /dev/null
+++ b/Project_tests/other/BerishaAlma/test2 converter.py
@@ -0,0 +1,37 @@
+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
diff --git a/Project_tests/other/GotsisWasilios/TDD_Converter.py b/Project_tests/other/GotsisWasilios/TDD_Converter.py
new file mode 100644
index 0000000..36a0518
--- /dev/null
+++ b/Project_tests/other/GotsisWasilios/TDD_Converter.py
@@ -0,0 +1,51 @@
+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()
+
diff --git a/Project_tests/other/PikkemaatLasse/calculator.py b/Project_tests/other/PikkemaatLasse/calculator.py
new file mode 100644
index 0000000..e799761
--- /dev/null
+++ b/Project_tests/other/PikkemaatLasse/calculator.py
@@ -0,0 +1,29 @@
+#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()
diff --git a/Project_tests/other/PikkemaatLasse/counter.py b/Project_tests/other/PikkemaatLasse/counter.py
new file mode 100644
index 0000000..00cf9c0
--- /dev/null
+++ b/Project_tests/other/PikkemaatLasse/counter.py
@@ -0,0 +1,48 @@
+#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
diff --git a/Project_tests/other/PikkemaatLasse/interfaces.py b/Project_tests/other/PikkemaatLasse/interfaces.py
new file mode 100644
index 0000000..fc64573
--- /dev/null
+++ b/Project_tests/other/PikkemaatLasse/interfaces.py
@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class IRomanNumerals(ABC):
+ @abstractmethod
+ def to_roman(self, num):
+ pass
\ No newline at end of file
diff --git a/Project_tests/other/WeishauptOrlando/src/Count_ED.py b/Project_tests/other/WeishauptOrlando/src/Count_ED.py
new file mode 100644
index 0000000..3b6973a
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/src/RomanConverter.py b/Project_tests/other/WeishauptOrlando/src/RomanConverter.py
new file mode 100644
index 0000000..e45a5e2
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/src/__init__.py b/Project_tests/other/WeishauptOrlando/src/__init__.py
new file mode 100644
index 0000000..1b733ab
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/src/calculator.py b/Project_tests/other/WeishauptOrlando/src/calculator.py
new file mode 100644
index 0000000..f4b4785
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/src/interfaces.py b/Project_tests/other/WeishauptOrlando/src/interfaces.py
new file mode 100644
index 0000000..e9c300f
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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
diff --git a/Project_tests/other/WeishauptOrlando/tests/TestCount_ED.py b/Project_tests/other/WeishauptOrlando/tests/TestCount_ED.py
new file mode 100644
index 0000000..152bccd
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/tests/__init__.py b/Project_tests/other/WeishauptOrlando/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/Project_tests/other/WeishauptOrlando/tests/test_calculator.py b/Project_tests/other/WeishauptOrlando/tests/test_calculator.py
new file mode 100644
index 0000000..a0c7931
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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/Project_tests/other/WeishauptOrlando/tests/test_roman.py b/Project_tests/other/WeishauptOrlando/tests/test_roman.py
new file mode 100644
index 0000000..30cbabf
--- /dev/null
+++ b/Project_tests/other/WeishauptOrlando/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
diff --git a/Project_tests/other/YildirimHatice/converter.py b/Project_tests/other/YildirimHatice/converter.py
new file mode 100644
index 0000000..0ef9bd0
--- /dev/null
+++ b/Project_tests/other/YildirimHatice/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()
diff --git a/Project_tests/report.md b/Project_tests/report.md
new file mode 100644
index 0000000..5369401
--- /dev/null
+++ b/Project_tests/report.md
@@ -0,0 +1,9 @@
+| Name | Interface break | Failed Testcases |
+|--------------|-----------------|---------------------------------------------------------|
+| AliciMuhamed | yes (4) | test_convertFloat test_convertNegative test_convertZero |
+| | | |
+| | | |
+| | | |
+| | | |
+| | | |
+| | | |
\ No newline at end of file
diff --git a/__pycache__/calculator.cpython-312.pyc b/__pycache__/calculator.cpython-312.pyc
deleted file mode 100644
index 0c79c8eed669ab1f2545621177cf866fa57d22f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3501
zcmd5;UvC>l5Z}E&_QkQCq)lj`spB-IaDfCOpb{lQ4W$JtWCEp#T9M4zw@GdMC+wZm
z+6t%-c}N~mB2^+m;tNFi3VZ{eq7o%Kfk5KPZy^_i)F)>4Y{zy@(h453C(Z57?9S}Y
z{$^%>3WWj$+Jo<%*_2AiA2_Hr7>nk91HUz55|d_0j>c(Dic6G8<UL|ai^P-}-ITql
zaanK`;Hpfna}`+Y%c^k|{{E~lr^J=&dJSfFFf|kQ);H4nYOUnc0~HkMk|R&PbJYnO
zNz3L&%FZ$SPQgqyE|aPQ_e1Ec5k}(FByow!CS4?(RbgC#G3>oQhTWQS!`KI7I7MCV
zFR8lE>HOfTkxdn|hF##P>XGZVaqKF>Xo+ml*aq2<9mQhV8HXAUO<Fi18jU{6q%Ke2
zvKY6f-=CWPD9_&I>3KFi#f^JuYmOH(>`Oa(ljWFYGakJ(J=Z80wOQ&;zK|`<rdiUk
z(u~_|G@Z{E<_$Yt$g})(s=mXqxsoFrrdjT4*!CDOaFZ_H?tSvR7IdLQjy?_7U<&U*
zf^eywgyXF_vQ<nrn*fGb(2WavfczKjxnj0iJ1~N%_<zxErstcr14AgTYme!gqa_k~
zBgYa6Cy+?w3T82j{a_;TRnf?L5{^#gT}VzN=|ge`iEtZwLAZ<iu!jWUU`+v8B)jVA
zKP9S$T$%WK_prC;gWl8g#0ueZVIl?E>y1`>?gi)^1_p*jTm(a0!4QBT1>nbh0`P%<
z!8-<-z&qZ=8d;zVQW<(T$x%oV-YJI<RU#Ijfn{zdko#n}t9x~PxwsU395e0g0TPd~
zhZoUg4}keB@OT8tW58@@1ft{^BY4qGMgX4!PiF*<e~b|XQj-yY>0pzQnC|EO$Pov8
z4tq}kMzK*OcnS;eVv+0v{`&TPHR58=gA`7T>6GKYJ+xj0$??!KRREaZ^a0gMeu%H|
zr;zLpagnM)6|_N_sY30%&~4XcwcNZw5_Mk51E4O6JvubCK{<lU!WmI7U#S+eZ_Sl^
zn{AE>?u$6rL*p+!XCDkKDc|}$pwvyk3=DOF{x6^d=qDNYx3&z<XlW)jrA<5#w67_w
ztCd)fCFlY*<=PxdN<>#;6;xHhxfRT-y3C)4pSWMA)3BhF*w-)<ZAjv<j?DP1g=V7F
zBWpJJH-V+#Ov|Zjf|p^obrA@JVffU_%<{}iW;wIovp)GS99fcgwcw7{zoqrBpI$e%
zwde`(2^J!*1F86d)O;dxFCK=E0%_v}ELLru0D^H?;y&(#Q|li;3=f`2Cm<3lSWGGy
z`!y$s+H;f>u%@<k0thaFq9;T`a$6fZ0Z8bD9dq0^A8BxcsJ%xy0ZV^dCxGBB)b=_O
zQ6(CKzgD{4RS=8dZ<GQLn_UfZLN=??HweW<ffv@&GKk-n)|e<LzP#aUObWwf9CF%S
zc!l2vy_hEM$+yW}s>?BsDCTHiSDc`i9X>JA7PFkdXGXTju5n)AUIr09LcllX$8M1m
zzzK<DDN$y;P#$cTG#VycK@DR-AbEs(c0!S@P~?a5c4%Zb*u8Rn`TEL@<r}Mfef;O(
zxxZx+erYE(vK1P6WZ}!`yK@urkLslAkLew)1?&Zo^H-3(hU85o6G*NgX?a%-BM*r<
zPZT;($`q<b_BBZz+7DF8dC_xW7!h|XmgpVuP)?>e=2`C{hqvt25UrR`+vpM}aQL)#
zG|wfFdWGHQy*S#0_egx3Ujsde0P8Z4J(*Ja8yP-Ox@c&1_<+Fg;6f+uTRnR~;O7ny
b+WjjTI#32^WcBl%zKdIZ7ylwK5L^8Rl8bv*
--
GitLab