From 9cad7344ed8efe7c8dc6cbf6bc0b49874ea967e3 Mon Sep 17 00:00:00 2001
From: Muhamed <Muhamedalici@hotmail.de>
Date: Sat, 5 Apr 2025 20:46:07 +0200
Subject: [PATCH] Update Roman Calc
---
"Test_Converter_R\303\266mische_Zahlen.py" | 52 +++--
.../other/alma/import unittest.py | 50 +++++
.../other/alma/test2 converter.py | 37 ++++
muhamed_directory/other/daniel/converter.py | 182 ++++++++++++++++++
muhamed_directory/other/hatice/calculator.py | 13 ++
muhamed_directory/other/hatice/converter.py | 49 +++++
muhamed_directory/other/hatice/counter.py | 35 ++++
muhamed_directory/other/hatice/test.py | 5 +
muhamed_directory/other/lasse/Test.py | 2 +
muhamed_directory/other/lasse/calculator.py | 29 +++
muhamed_directory/other/lasse/counter.py | 48 +++++
muhamed_directory/other/lasse/interfaces.py | 6 +
muhamed_directory/other/lasse/main.py | 0
.../other/lasse/romannumerals.py | 23 +++
.../other/lasse/test_romannumerals.py | 108 +++++++++++
.../other/orlando/TestCount_ED.py | 34 ++++
muhamed_directory/other/orlando/__init__.py | 0
.../other/orlando/test_calculator.py | 103 ++++++++++
muhamed_directory/other/orlando/test_roman.py | 66 +++++++
.../other/wasili/TDD_Converter.py | 51 +++++
.../other/wasili/Testszenarios.txt | 7 +
21 files changed, 881 insertions(+), 19 deletions(-)
create mode 100644 muhamed_directory/other/alma/import unittest.py
create mode 100644 muhamed_directory/other/alma/test2 converter.py
create mode 100644 muhamed_directory/other/daniel/converter.py
create mode 100644 muhamed_directory/other/hatice/calculator.py
create mode 100644 muhamed_directory/other/hatice/converter.py
create mode 100644 muhamed_directory/other/hatice/counter.py
create mode 100644 muhamed_directory/other/hatice/test.py
create mode 100644 muhamed_directory/other/lasse/Test.py
create mode 100644 muhamed_directory/other/lasse/calculator.py
create mode 100644 muhamed_directory/other/lasse/counter.py
create mode 100644 muhamed_directory/other/lasse/interfaces.py
create mode 100644 muhamed_directory/other/lasse/main.py
create mode 100644 muhamed_directory/other/lasse/romannumerals.py
create mode 100644 muhamed_directory/other/lasse/test_romannumerals.py
create mode 100644 muhamed_directory/other/orlando/TestCount_ED.py
create mode 100644 muhamed_directory/other/orlando/__init__.py
create mode 100644 muhamed_directory/other/orlando/test_calculator.py
create mode 100644 muhamed_directory/other/orlando/test_roman.py
create mode 100644 muhamed_directory/other/wasili/TDD_Converter.py
create mode 100644 muhamed_directory/other/wasili/Testszenarios.txt
diff --git "a/Test_Converter_R\303\266mische_Zahlen.py" "b/Test_Converter_R\303\266mische_Zahlen.py"
index d98f342..7d4aada 100644
--- "a/Test_Converter_R\303\266mische_Zahlen.py"
+++ "b/Test_Converter_R\303\266mische_Zahlen.py"
@@ -1,36 +1,50 @@
#Test_Converter_Römische_Zahlen
import unittest
+from abc import ABC, abstractmethod
-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 test_1(self):
- self.assertEqual(convert(1), "I") # Erwartet "I" für 1
+ self.assertEqual(Converter.convert(1), "I") # Erwartet "I" für 1
def test_10(self):
- self.assertEqual(convert(10), "X") # Erwartet "X" für 10
+ self.assertEqual(Converter.convert(10), "X") # Erwartet "X" für 10
+
def test_21(self):
- self.assertEqual(convert(21), "XXI") # Erwartet "XXI" für 21
+ self.assertEqual(Converter.convert(21), "XXI") # Erwartet "XXI" für 21
+
def test_50(self):
- self.assertEqual(convert(50), "L") # Erwartet "L" für 50
+ self.assertEqual(Converter.convert(50), "L") # Erwartet "L" für 50
+
def test_100(self):
- self.assertEqual(convert(100), "C") # Erwartet "C" für 100
+ self.assertEqual(Converter.convert(100), "C") # Erwartet "C" für 100
+
def test_1000(self):
- self.assertEqual(convert(1000), "M") # Erwartet "M" für 1000
+ self.assertEqual(Converter.convert(1000), "M") # Erwartet "M" für 1000
+
def test_1999(self):
- self.assertEqual(convert(1999), "MCMXCIX") #Erwartet "MCMXCIX" für 1999
+ self.assertEqual(Converter.convert(1999), "MCMXCIX") # Erwartet "MCMXCIX" für 1999
if __name__ == "__main__":
unittest.main()
\ No newline at end of file
diff --git a/muhamed_directory/other/alma/import unittest.py b/muhamed_directory/other/alma/import unittest.py
new file mode 100644
index 0000000..c1b2fe7
--- /dev/null
+++ b/muhamed_directory/other/alma/import unittest.py
@@ -0,0 +1,50 @@
+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
diff --git a/muhamed_directory/other/alma/test2 converter.py b/muhamed_directory/other/alma/test2 converter.py
new file mode 100644
index 0000000..2e04e94
--- /dev/null
+++ b/muhamed_directory/other/alma/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/muhamed_directory/other/daniel/converter.py b/muhamed_directory/other/daniel/converter.py
new file mode 100644
index 0000000..1d5eff4
--- /dev/null
+++ b/muhamed_directory/other/daniel/converter.py
@@ -0,0 +1,182 @@
+# 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()
diff --git a/muhamed_directory/other/hatice/calculator.py b/muhamed_directory/other/hatice/calculator.py
new file mode 100644
index 0000000..79532fc
--- /dev/null
+++ b/muhamed_directory/other/hatice/calculator.py
@@ -0,0 +1,13 @@
+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
diff --git a/muhamed_directory/other/hatice/converter.py b/muhamed_directory/other/hatice/converter.py
new file mode 100644
index 0000000..0ef9bd0
--- /dev/null
+++ b/muhamed_directory/other/hatice/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/muhamed_directory/other/hatice/counter.py b/muhamed_directory/other/hatice/counter.py
new file mode 100644
index 0000000..f6ee3bb
--- /dev/null
+++ b/muhamed_directory/other/hatice/counter.py
@@ -0,0 +1,35 @@
+#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()
diff --git a/muhamed_directory/other/hatice/test.py b/muhamed_directory/other/hatice/test.py
new file mode 100644
index 0000000..d40dcf9
--- /dev/null
+++ b/muhamed_directory/other/hatice/test.py
@@ -0,0 +1,5 @@
+#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
diff --git a/muhamed_directory/other/lasse/Test.py b/muhamed_directory/other/lasse/Test.py
new file mode 100644
index 0000000..903e6d7
--- /dev/null
+++ b/muhamed_directory/other/lasse/Test.py
@@ -0,0 +1,2 @@
+print("Hello WORLD")
+print("test")
\ No newline at end of file
diff --git a/muhamed_directory/other/lasse/calculator.py b/muhamed_directory/other/lasse/calculator.py
new file mode 100644
index 0000000..e799761
--- /dev/null
+++ b/muhamed_directory/other/lasse/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/muhamed_directory/other/lasse/counter.py b/muhamed_directory/other/lasse/counter.py
new file mode 100644
index 0000000..00cf9c0
--- /dev/null
+++ b/muhamed_directory/other/lasse/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/muhamed_directory/other/lasse/interfaces.py b/muhamed_directory/other/lasse/interfaces.py
new file mode 100644
index 0000000..fc64573
--- /dev/null
+++ b/muhamed_directory/other/lasse/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/muhamed_directory/other/lasse/main.py b/muhamed_directory/other/lasse/main.py
new file mode 100644
index 0000000..e69de29
diff --git a/muhamed_directory/other/lasse/romannumerals.py b/muhamed_directory/other/lasse/romannumerals.py
new file mode 100644
index 0000000..3f3eaf1
--- /dev/null
+++ b/muhamed_directory/other/lasse/romannumerals.py
@@ -0,0 +1,23 @@
+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
diff --git a/muhamed_directory/other/lasse/test_romannumerals.py b/muhamed_directory/other/lasse/test_romannumerals.py
new file mode 100644
index 0000000..9a774cc
--- /dev/null
+++ b/muhamed_directory/other/lasse/test_romannumerals.py
@@ -0,0 +1,108 @@
+# 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
diff --git a/muhamed_directory/other/orlando/TestCount_ED.py b/muhamed_directory/other/orlando/TestCount_ED.py
new file mode 100644
index 0000000..152bccd
--- /dev/null
+++ b/muhamed_directory/other/orlando/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/muhamed_directory/other/orlando/__init__.py b/muhamed_directory/other/orlando/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/muhamed_directory/other/orlando/test_calculator.py b/muhamed_directory/other/orlando/test_calculator.py
new file mode 100644
index 0000000..a0c7931
--- /dev/null
+++ b/muhamed_directory/other/orlando/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/muhamed_directory/other/orlando/test_roman.py b/muhamed_directory/other/orlando/test_roman.py
new file mode 100644
index 0000000..30cbabf
--- /dev/null
+++ b/muhamed_directory/other/orlando/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/muhamed_directory/other/wasili/TDD_Converter.py b/muhamed_directory/other/wasili/TDD_Converter.py
new file mode 100644
index 0000000..36a0518
--- /dev/null
+++ b/muhamed_directory/other/wasili/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/muhamed_directory/other/wasili/Testszenarios.txt b/muhamed_directory/other/wasili/Testszenarios.txt
new file mode 100644
index 0000000..1320563
--- /dev/null
+++ b/muhamed_directory/other/wasili/Testszenarios.txt
@@ -0,0 +1,7 @@
+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"
--
GitLab