diff --git a/Other/AliciMuhamed_2/String calculator b/Other/AliciMuhamed_2/String calculator
new file mode 100644
index 0000000000000000000000000000000000000000..fc44a5aa2e889ec677e3551e4659dcd805a9cb33
--- /dev/null
+++ b/Other/AliciMuhamed_2/String calculator
@@ -0,0 +1,136 @@
+#vorher im anderen projekt jetzt im neuen projekt
+#test no string
+#test add 1 string
+#test adding 2 strings
+
+#add 3 strings
+#add 4 strings
+#add 6 strings
+
+#\n statt , bei 2 strings
+#\n statt , bei mehreren strings
+
+# eine negative zahl
+# mehrere negative zahlen
+
+# Delimiters:
+# add numbers seperated by a custom delimiter
+# Test with - Numbers
+
+#numbers over 1000 should be ignored
+#1001 + 2 should return 2
+#1001 -2 should return negatives not allowed
+
+#custom delimiters
+#input "//[***]\n1***2***3"
+#output 6
+
+import unittest
+import re
+
+class StringCalculator:
+ def __init__(self):
+ self.called_count = 0
+ def add (self, numbers : str)-> int: #Erwartet Integer
+ if not numbers:
+ return 0
+
+ if numbers.startswith("//"):
+ delimiter_end_index = numbers.index("\n")
+ delimiter_section = numbers[2:delimiter_end_index]
+ numbers = numbers[delimiter_end_index +1:]
+
+ if delimiter_section.startswith("[")and delimiter_section.endswith("]"):
+ delimiters = re.findall(r'\[([^\]]+)\]',delimiter_section)
+ else:
+ delimiters= [delimiter_section]
+
+ for delimiters in delimiters:
+ numbers = numbers.replace(delimiters,",")
+
+ numbers = numbers.replace("\n",",")
+
+ number_list = numbers.split(',')#aufteilung der strings
+ negative = [] #array für die negativen nummern
+ numbers_to_add = []
+ #total_sum = 0
+ for number_str in number_list: #jedes element in der liste wird durch genommen
+ #if number_str:
+ number = int(number_str)# summierung der integer
+ if number <0:
+ negative.append(number)
+ elif number > 1000:
+ continue
+ else:
+ numbers_to_add.append(number)
+ #total_sum += number
+
+ if negative:
+ print(f"Negative Zahlen:{negative} ")#ausgabe negative zahlen
+ raise ValueError(f"negatives not allowed: {','.join(map(str, negative))}")
+ self.called_count += 1
+ return sum(numbers_to_add)
+ def get_called_count(self):
+ return self.called_count
+
+
+class TestStingCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+ def test_empty_string(self):
+ self.assertEqual(self.calculator.add(""), 0) #leerer string + 0
+ def test_single_number(self):
+ self.assertEqual(self.calculator.add("5"),5) #eingabe von einem String
+ def test_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("5,5"),10)#eingabe mehrere strings
+ def test_unknowen_amount_of_numbers(self):
+ self.assertEqual(self.calculator.add("1,2,3"),6)
+ self.assertEqual(self.calculator.add("10,20,30,40"),100)
+ self.assertEqual(self.calculator.add("1,2,3,4,5,6"),21)
+ def test_numbers_seperated_by_newline(self):
+ self.assertEqual(self.calculator.add("1\n2"),3)
+ self.assertEqual(self.calculator.add("1\n2\n3"),6)
+ self.assertEqual(self.calculator.add("10,20\n30"),60)
+
+ def test_negative_number_exception(self):
+
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1,2")
+ self.assertEqual(str(e.exception), "negatives not allowed: -1")
+ def test_multiple_negative_numbers_exception(self):
+ with self.assertRaises(ValueError)as e:
+ self.calculator.add("-1,-2,3")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-2")
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1,-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")
+
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1\n-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")
+ def test_add_numbers_with_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n1;2;3"),6)
+ self.assertEqual(self.calculator.add("//;\n1,2,3"),6)
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("//;\n-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -3")
+
+ def test_add_numbers_greater_than_1000(self):
+ self.assertEqual(self.calculator.add("1,1001,2,3"),6)
+ def test_add_numbers_greater_than_1000_1002(self):
+ self.assertEqual(self.calculator.add("1002,1,2,3"),6)
+ def test_add_numbers_greater_1000_and_minus(self):
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("//;\n-3,4;1001")
+ self.assertEqual(str(e.exception),"negatives not allowed: -3")
+ def test_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//[***]\n1***2***3"),6)
+ def test_custom_del(self):
+ self.assertEqual(self.calculator.add("//[+++]\n1+++2+++3"),6)
+ def test_custom_del2(self):
+ self.assertEqual(self.calculator.add("//[aa]\n1aa2aa3"),6)
+
+
+
+if __name__=='__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc
index 268009bebff13d3c53c3ef6e1f80c2ba5edc84c2..a8cf6e6c5489f1becc13f385c49656466534422b 100644
Binary files a/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc and b/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc differ
diff --git a/Other/AliciMuhamed_2/my_calculator.py b/Other/AliciMuhamed_2/my_calculator.py
index 0d6c00354c095887fb757bb36c133a993e602a07..fda18662fd76fee2779d2aee97ad11dde3576073 100644
--- a/Other/AliciMuhamed_2/my_calculator.py
+++ b/Other/AliciMuhamed_2/my_calculator.py
@@ -1,14 +1,14 @@
#Implementierung von AliciMuhamed auf meinen Testfälle: StringCalculator
import unittest
-
-from string calculator import StringCalculator
+from String Calculator import IStringCalculator
+from String Calculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/AliciMuhamed_2/your_calculator.py b/Other/AliciMuhamed_2/your_calculator.py
index 0c826a8582885dceeed6035ba2be8fb9846f1f5b..ee41498417ce6cb671230af09f7089759768b600 100644
--- a/Other/AliciMuhamed_2/your_calculator.py
+++ b/Other/AliciMuhamed_2/your_calculator.py
@@ -3,14 +3,14 @@
import unittest
from stringCalculator import StringCalculator
-
+from stringCalculator import IStringCalculator
class TestStingCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0) #leerer string + 0
diff --git a/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc b/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc
index 5047f7559a0813d308e85fae57458ace61d9a67f..f1e5ec1d5ce5eb500a42111a816b63d1373577c9 100644
Binary files a/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc and b/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc differ
diff --git a/Other/BerishaAlma_2/my_calculator.py b/Other/BerishaAlma_2/my_calculator.py
index 8ac359bd5ab644f8481587890a59256a6dff02c1..1504f02c0670b28040b2b80af532a4236258d87d 100644
--- a/Other/BerishaAlma_2/my_calculator.py
+++ b/Other/BerishaAlma_2/my_calculator.py
@@ -2,13 +2,14 @@
import unittest
from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/BerishaAlma_2/your_calculator.py b/Other/BerishaAlma_2/your_calculator.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..1504f02c0670b28040b2b80af532a4236258d87d 100644
--- a/Other/BerishaAlma_2/your_calculator.py
+++ b/Other/BerishaAlma_2/your_calculator.py
@@ -0,0 +1,59 @@
+#Implementierung von BerishaAlma auf meinen Testfälle: StringCalculator
+import unittest
+
+from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+
+ def test_implements_interface(self):
+ self.assertIsInstance(self.calculator, IStringCalculator)
+
+ def test_empty_string(self):
+ self.assertEqual(self.calculator.add(""), 0)
+
+ def test_single_number(self):
+ self.assertEqual(self.calculator.add("1"), 1)
+
+ def test_two_numbers(self):
+ self.assertEqual(self.calculator.add("1,2"), 3)
+
+ def test_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)
+
+ def test_numbers_with_newline(self):
+ self.assertEqual(self.calculator.add("1\n2,3"), 6)
+
+ def test_numbers_with_multiple_newlines(self):
+ self.assertEqual(self.calculator.add("1\n2\n3\n4\n5"), 15)
+
+ def test_negative_number(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("1,-2,3")
+ self.assertEqual(str(context.exception), "Negatives not allowed: -2")
+
+ def test_multiple_negative_numbers(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("1,-2,-3,4")
+ self.assertEqual(str(context.exception), "Negatives not allowed: -2, -3")
+
+ def test_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n1;2"), 3)
+
+ def test_custom_delimiter_with_newline(self):
+ self.assertEqual(self.calculator.add("//;\n1;2\n3"), 6)
+
+ def test_custom_delimiter_with_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("//|\n1|2|3|4"), 10)
+
+ def test_numbers_greater_than_1000(self):
+ self.assertEqual(self.calculator.add("2,1001"), 2)
+
+ def test_numbers_greater_than_1000_with_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n2;1001"), 2)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc b/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac3ffe37efbe798d63fec133056f67d5dc7bd672
Binary files /dev/null and b/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc differ
diff --git a/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a37db71ef9cd99b8c9c9f6794e641eac1bc8cf9
Binary files /dev/null and b/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc differ
diff --git a/Other/GotsisWasili_2/my_calculator.py b/Other/GotsisWasili_2/my_calculator.py
index ab49b59b82ff38ff3a846ff995e6a05d74b23f2f..c4fe03dde01ddd47b87d47ec890719c1dce1dbd3 100644
--- a/Other/GotsisWasili_2/my_calculator.py
+++ b/Other/GotsisWasili_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
import unittest
-
+from TDD_StringCalculator import IStringCalculator
from TDD_StringCalculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/GotsisWasili_2/your_calculator.py b/Other/GotsisWasili_2/your_calculator.py
index 9742055e19c1c682398e33e44b50f9b8ef9d85f7..e2a8d707b02ca987621ed8b0b2d65b2fbb86103f 100644
--- a/Other/GotsisWasili_2/your_calculator.py
+++ b/Other/GotsisWasili_2/your_calculator.py
@@ -1,12 +1,13 @@
import unittest
from stringCalculator import StringCalculator
+from stringCalculator import IStringCalculator
#mplementierung der Testklasse für StringCalculator
class TestStringCalculator(unittest.TestCase):
def test_implements_interface(self):
c = StringCalculator()
- self.assertIsInstance(self.c, StringCalculator)
+ self.assertIsInstance(self.c, IStringCalculator)
def test_add_empty(self):
c = StringCalculator()
diff --git a/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc
index f8f6330f0744cb9f2196855a68b226d8671fd74e..1ff7783d8414bad0c1e6d27e8b601993b67297fe 100644
Binary files a/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc and b/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc differ
diff --git a/Other/PikkemaatLasse_2/my_calculator.py b/Other/PikkemaatLasse_2/my_calculator.py
index 13972760a46d75cb5ea1e9a7e221003e704af29e..4ec2a93baaab252644714b8eff9a5fb256a1cb9d 100644
--- a/Other/PikkemaatLasse_2/my_calculator.py
+++ b/Other/PikkemaatLasse_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
import unittest
-
+from src.interfaces import IStringCalculator
from src.stringcalculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc b/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc
index ac53ca6f524d1c5c8f88faf49192e432080c7686..699a52065ec2a07ec55dbe872ca09053b4c97c0e 100644
Binary files a/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc and b/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc differ
diff --git a/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc b/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc
index d7070b361211a079a6b1902fa1be15345de2abe3..14633fbfbac1c8d5bbae2b57c32ed6e4e91a8cb0 100644
Binary files a/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc and b/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc differ
diff --git a/Other/PikkemaatLasse_2/src/interfaces.py b/Other/PikkemaatLasse_2/src/interfaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..53246cf689694abc6d024abf602d890c37fb07f3
--- /dev/null
+++ b/Other/PikkemaatLasse_2/src/interfaces.py
@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ pass
\ No newline at end of file
diff --git a/Other/PikkemaatLasse_2/src/stringcalculator.py b/Other/PikkemaatLasse_2/src/stringcalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc7e89a3c15a18957c55241afea7767fcad48f34
--- /dev/null
+++ b/Other/PikkemaatLasse_2/src/stringcalculator.py
@@ -0,0 +1,36 @@
+from src.interfaces import IStringCalculator
+import re
+
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+ if not numbers:
+ return 0
+
+ if numbers.startswith("//"):
+ if "\n" not in numbers:
+ raise ValueError("Ungültiges Format: Nicht vollständig")
+ delimiter_end_index = numbers.index("\n")
+ delimiter_part = numbers[2:delimiter_end_index]
+ if delimiter_part.startswith("[") and delimiter_part.endswith("]"):
+ delimiter = delimiter_part[1:-1]
+ else:
+ delimiter = delimiter_part
+ numbers = numbers[delimiter_end_index + 1:]
+ numbers = numbers.replace(delimiter, ",")
+
+ numbers = numbers.replace("\n", ",")
+
+ # Split the string by commas, convert each value to an integer, and sum them up
+ try:
+ numbers_list = list(map(int, numbers.split(",")))
+ except ValueError:
+ raise ValueError("Ungültiges Zahlenformat: Enthält nicht-numerische Werte")
+
+ negative_numbers = [num for num in numbers_list if num < 0]
+ if negative_numbers:
+ raise ValueError(f"Negative nicht erlaubt: {negative_numbers}")
+
+ numbers_list = [num for num in numbers_list if num <= 1000]
+
+ return sum(numbers_list)
\ No newline at end of file
diff --git a/Other/PikkemaatLasse_2/tests/test_stringclaculator.py b/Other/PikkemaatLasse_2/tests/test_stringclaculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2e765bd59b8d7d50121700aa53d98082b57a32f
--- /dev/null
+++ b/Other/PikkemaatLasse_2/tests/test_stringclaculator.py
@@ -0,0 +1,85 @@
+# Basis
+# Bei Eingabe keiner Zahl soll eine 0 ausgegeben werden
+# Bei Eingabe einer 1 soll 1 ausgegeben werden
+# Bei Eingabe einer 3,4 soll 7 ausgegeben werden
+# Bei Eingabe einer 10,20 soll 30 ausgegeben werden
+#Feature1 Längere Zahlenfolge
+# Bei Eingabe einer 1,2,3 soll 6 ausgegeben werden
+# Bei Eingabe einer 10,20,30,40 soll 100 ausgegeben werden
+#Feature2 Neues Trennzeichen neben dem Komma
+# Bei Eingabe von 1\n2,3 soll 6 ausgegeben werden
+# Bei Eingabe von 10\n20\n30 soll 60 ausgegeben werden
+#Feature3 Negative Zahlen ausschließen
+# Bei Eingabe von 1, -2, 3 soll ein Error erscheinen "Negative nicht erlaubt: [-2]
+# Bei Eingabe von -10\n -20, -30 soll ein Error erscheinen "Negative nicht erlaubt: [-10,-20,30]
+#Feature4 Eigene Trennzeichen eingeben
+# Bei Eingabe eines neuen Trennzeichen ";" //;\n1;2 soll 3 ausgegeben werden
+# Bei Eingabe eines neuen Trennzeichen "x" //-\n7x8\n9 soll 24 ausgegeben werden
+# Bei Eingabe eines neuen Trennzeichens ";" ohne vollständigen Ausdrück //;1;2 soll Ungültiges Format: Nicht vollständig
+#Feature5 Zahlen größer 1000 nicht erkennen
+# Bei Eingabe von 2,1001 soll 2 ausgegeben werden
+# Bei Eingabe von 1002, 50200 soll 0 asugegeben werden
+#Feature6 Begrenzungszeichen beliebig lang
+# Bei Eingabe von //[**]\n1**2**3 soll 6 ausgegeben werden
+# Bei Eingabe von //[###]\n10###20###30 soll 60 ausgegeben werden
+
+
+import unittest
+from src.interfaces import IStringCalculator
+from src.stringcalculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator: IStringCalculator = StringCalculator() # Zugriff über das Interface
+
+ def test_add_empty_string(self):
+ self.assertEqual(self.calculator.add(""), 0)
+
+ def test_add_single_number(self):
+ self.assertEqual(self.calculator.add("1"), 1)
+
+ def test_add_two_numbers(self):
+ self.assertEqual(self.calculator.add("10,20"), 30)
+
+ def test_add_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("1,2,3"), 6)
+ self.assertEqual(self.calculator.add("10,20,30,40"), 100)
+
+ def test_add_with_newline_separator(self):
+ self.assertEqual(self.calculator.add("1\n2,3"), 6)
+ self.assertEqual(self.calculator.add("10\n20\n30"), 60)
+
+ def test_add_single_negative_number(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("1,-2,3")
+ print(str(context.exception))
+ self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-2]")
+
+ def test_add_multiple_negative_numbers(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("-10\n-20,-30")
+ print(str(context.exception))
+ self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-10, -20, -30]")
+
+ def test_add_with_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n1;2"), 3)
+ self.assertEqual(self.calculator.add("//x\n7x8\n9"), 24)
+
+ def test_invalid_custom_delimiter_format(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("//;1;2")
+ print(str(context.exception))
+
+ def test_ignore_numbers_greater_than_1000(self):
+ self.assertEqual(self.calculator.add("2,1001"), 2)
+ self.assertEqual(self.calculator.add("1002,50200"), 0)
+
+ def test_add_with_custom_delimiter_multiple_characters(self):
+ self.assertEqual(self.calculator.add("//[**]\n1**2**3"), 6)
+ self.assertEqual(self.calculator.add("//[###]\n10###20###30"), 60)
+
+if __name__ == "__main__":
+ unittest.main()
+
+# python -m unittest tests.test_stringcalculator
+# python -m unittest discover -s tests -v
\ No newline at end of file
diff --git a/Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc b/Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4716d2ae5e17a9434dc49e7abc56a57608db4e95
Binary files /dev/null and b/Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc differ
diff --git a/Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc b/Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44061ca184162b9ad3b7368054757a969e63e88e
Binary files /dev/null and b/Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc differ
diff --git a/Other/RafehDaniel_2/my_calculator.py b/Other/RafehDaniel_2/my_calculator.py
index 29b3e3c8694674935051beb38d70366e76ef8a4e..6a58a727758cd82c2cced313f53a8871e509d917 100644
--- a/Other/RafehDaniel_2/my_calculator.py
+++ b/Other/RafehDaniel_2/my_calculator.py
@@ -1,14 +1,14 @@
#Umsetzungen von RafehDaniel auf meinen Testfälle: StringCalculator
import unittest
-
-from stringCalculator import StringCalculator
+from stringCalculatorDaniel import IStringCalculator
+from stringCalculatorDaniel import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/RafehDaniel_2/stringCalculatorDaniel.py b/Other/RafehDaniel_2/stringCalculatorDaniel.py
new file mode 100644
index 0000000000000000000000000000000000000000..232cb01f86f1783dee257ad584d3ff6cf2848a2a
--- /dev/null
+++ b/Other/RafehDaniel_2/stringCalculatorDaniel.py
@@ -0,0 +1,171 @@
+# Bei einer leeren Eingabe "" soll die Zahl 0 ausgegeben werden.
+# Bei der Eingabe "1" soll die 1 ausgegeben werden.
+# Bei der Eingabe von 2 Zahlen als Strings separiert durch "," (z.B. "1, 2") soll die Zahl 3 ausgegeben werden
+# Bei der Eingabe "0, 5" soll die Zahl 5 ausgegeben werden.
+# Bei der Eingabe von Float-Werten z.B. 3.5 soll "only integers allowed" ausgegeben werden.
+# Bei der Eingabe von Buchstaben z.B. 1, z soll "only integers allowed" ausgegeben werden.
+# Bei der Eingabe von 2 Zahlen als Strings separiert durch "\n" (z.B. "1\n2,3") soll 6 ausgegeben werden
+# Bei der Eingabe von negativen Zahlen (z.B. -3) soll "negatives not allowed" ausgegeben werden
+# Bei der Eingabe von Zahlen mit einem benutzerdefinierten Trennzeichen soll die Summe der Zahlen berechnet werden (z.B. //;\n1;2 = 3)
+# Bei Eingabe von Zahlen >1000 sollen diese ignoriert werden (z.B. 2 + 1001 = 2)
+# Bei der Eingabe von Zahlen mit einem benutzerdefinierten Trennzeichen soll die Summe der Zahlen berechnet werden. Trennzeichen können unbegrenzt lang sein (z.B. “//[***]\n1***2***3†= 6).
+# Bei der Eingabe mehrerer negativen Zahlen (z.B. -3, -4) sollen die Zahlen in der exception ausgegeben werden
+# Bei der Eingabe von Zahlen mit Leerzeichen soll dennoch die Summe ausgegeben werden (z.B." 4 , 5" = 9)
+# Bei der Eingabe "2, 1001, 5" soll die Zahl 7 ausgegeben werden
+# Bei der Eingabe von Texten mit leeren Trennzeichen (z.B. "//;\n") soll die Zahl 0 ausgegeben werden
+# Bei der Eingabe von "1, " soll die Zahl 1 ausgegeben werden
+# Bei der Eingabe von "-2, 5" soll "negatives not allowed" ausgegeben werden
+# Bei der Eingabe von "//;\n-1;2;1001;-3" soll "negatives not allowed [-1, -3]" ausgegeben werden
+
+import unittest
+from abc import ABC, abstractmethod
+
+
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ pass
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+
+ '''Leere Eingabe soll 0 ausgeben'''
+ if numbers == "":
+ return 0
+
+ '''Standard-Trennzeichen'''
+ delimiter = ";"
+
+ '''Es wird geprüft ob ein benutzerdefiniertes Trennzeichen vorhanden ist.'''
+ if numbers.startswith("//"):
+ sep = numbers.split("\n", 1)
+ delimiter_sep = sep[0][2:]
+
+ '''Für den Fall, dass das Trennzeichen in eckigen Klammern steht werden die Klammern entfernt und das Trennzeichen gespeichert'''
+ if delimiter_sep.startswith("[") and delimiter_sep.endswith("]"):
+ delimiter = delimiter_sep[1:-1]
+
+ else:
+ delimiter = delimiter_sep[0]
+
+ '''Entfernen der ersten Zeile, damit nur noch Zahlen übrig bleiben'''
+ numbers = sep[1]
+
+ '''Ersetzen von Zeilenumbrüchen mit Delimiter und ersetzen von Delimiter durch ",", um splitten zu können'''
+ numbers = numbers.replace("\n", delimiter).replace(delimiter, ",")
+
+ list = numbers.split(",")
+ result = 0
+
+ negative_numbers = []
+
+ for num in list:
+ num = num.strip()
+ if num == "":
+ continue
+
+ '''Sicherstellen dass Floats nicht berücksichtigt werden'''
+ if "." in num:
+ return "only integers allowed"
+
+ '''Sicherstellen, dass keine Buchstaben verwendet werden dürfen'''
+ try:
+ number = int(num)
+ except ValueError:
+ return "only integers allowed"
+
+ '''Konvertirung von Strings zu Integer'''
+ if number < 0:
+ negative_numbers.append(number)
+
+ if number > 1000:
+ continue
+
+ result += number
+
+ if len(negative_numbers) > 1:
+ return "negatives not allowed " + str(negative_numbers)
+ elif negative_numbers:
+ return "negatives not allowed"
+
+ return result
+
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.c = StringCalculator()
+
+ def test_empty(self):
+ res = self.c.add("")
+ self.assertEqual(res, 0)
+
+ def test_oneNumber(self):
+ res = self.c.add("1")
+ self.assertEqual(res, 1)
+
+ def test_addingTwoNumbers(self):
+ res = self.c.add("1,2")
+ self.assertEqual(res, 3)
+
+ def test_addingTwoNumbersWithZero(self):
+ res = self.c.add("0,5")
+ self.assertEqual(res, 5)
+
+ def test_handleFloat(self):
+ res = self.c.add("3.5")
+ self.assertEqual(res, "only integers allowed")
+
+ def test_handleLetter(self):
+ res = self.c.add("1, z")
+ self.assertEqual(res, "only integers allowed")
+
+ def test_addWithBackslashN(self):
+ res = self.c.add("1\n2,3")
+ self.assertEqual(res, 6)
+
+ def test_negativeValues(self):
+ res = self.c.add("-3")
+ self.assertEqual(res, "negatives not allowed")
+
+ def test_delimiter(self):
+ res = self.c.add("//;\n1;2")
+ self.assertEqual(res, 3)
+
+ def test_thousandone(self):
+ res = self.c.add("2, 1001")
+ self.assertEqual(res, 2)
+
+ def test_multidelimiter(self):
+ res = self.c.add("//[***]\n1***2***3")
+ self.assertEqual(res, 6)
+
+ def test_multi_negative(self):
+ res = self.c.add("-3, -4")
+ self.assertEqual(res, "negatives not allowed " + str([-3, -4]))
+
+ def test_space_between_numbers(self):
+ res = self.c.add(" 4 , 5")
+ self.assertEqual(res, 9)
+
+ def test_multiple_num_with_thousandone(self):
+ res = self.c.add(" 2, 1001, 5")
+ self.assertEqual(res, 7)
+
+ def test_empty_text(self):
+ res = self.c.add("//;\n")
+ self.assertEqual(res, 0)
+
+ def test_one_number_with_empty_string(self):
+ res = self.c.add("1,")
+ self.assertEqual(res, 1)
+
+ def test_negative_with_positive(self):
+ res = self.c.add("-2, 5")
+ self.assertEqual(res, "negatives not allowed")
+
+ def test_mixture(self):
+ res = self.c.add("//;\n-1;2;1001;-3")
+ self.assertEqual(res, "negatives not allowed " + str([-1, -3]))
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Other/RafehDaniel_2/your_calculator.py b/Other/RafehDaniel_2/your_calculator.py
index 64929f3a5a8e1c9fd1eb9368f2aba50fcb0b402f..6019b8886f8ff007531aec6ce2a458e2b3bf47dd 100644
--- a/Other/RafehDaniel_2/your_calculator.py
+++ b/Other/RafehDaniel_2/your_calculator.py
@@ -1,14 +1,15 @@
#Meine Implementierungen auf Testfälle anderer Studierenden testen: StringCalculator
import unittest
-from stringCalculator import StringCalculator
+from stringCalculatorr import IStringCalculator
+from stringCalculatorr import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.c = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.c, StringCalculator)
+ self.assertIsInstance(self.c, IStringCalculator)
def test_empty(self):
res = self.c.add("")
diff --git a/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc
index 481f23d725110b6364206a29d305bd4d7b6eaeed..8e3cc51fd5330f136d0658f11bb259688b766189 100644
Binary files a/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc and b/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc differ
diff --git a/Other/SerchimoMarvin_2/feature7 b/Other/SerchimoMarvin_2/feature7
new file mode 100644
index 0000000000000000000000000000000000000000..92de9259e2cee84a471e28f08d93682e34514b38
--- /dev/null
+++ b/Other/SerchimoMarvin_2/feature7
@@ -0,0 +1,127 @@
+import re
+import unittest
+
+class StringCalculator:
+ def add(self, numbers: str) -> int:
+ # Feature 1: Leerer String ergibt 0
+ if not numbers:
+ return 0
+
+
+
+ # Vorbereitung für weiter features
+ delimiters = [",", "\n"]
+ if numbers.startswith("//"):
+ delimiter_end_index = numbers.index("\n")
+ delimiter_section = numbers[2:delimiter_end_index]
+ numbers = numbers[delimiter_end_index + 1:]
+
+ # Feature 7: Delimiter beliebiger Länge im Format //[***]
+ if delimiter_section.startswith("[") and delimiter_section.endswith("]"):
+ delimiter = re.escape(delimiter_section[1:-1])
+ else:
+ delimiter = re.escape(delimiter_section)
+
+ delimiters.append(delimiter)
+
+ # Feature 3: Erlaube Zeilenumbrüche als Trenner
+ split_pattern = "|".join(delimiters)
+ number_list = re.split(split_pattern, numbers)
+
+
+
+
+ # Feature 4: Negativzahlen abfangen
+ negatives = []
+ for num in number_list:
+ if num.strip() != "":
+ value = int(num)
+ if value < 0:
+ negatives.append(value)
+
+ # Exception bei negativen Zahlen
+ if negatives:
+ raise ValueError(f"Negative numbers are not allowed: {', '.join(map(str, negatives))}")
+
+ # Feature 2: Beliebig viele Zahlen summieren
+ return sum(int(n) for n in number_list if n.strip() != "" and int(n) <= 1000)
+
+
+
+class TestStringCalculator(unittest.TestCase):
+ """Test suite for the StringCalculator class."""
+
+ def setUp(self):
+ """neue Instanz des StringCalculators vor jedem Test"""
+ self.calculator = StringCalculator()
+
+ def test_empty_string_returns_zero(self):
+ """Feature 1: Leerer String soll 0 ergeben"""
+ self.assertEqual(self.calculator.add(""), 0)
+
+ def test_single_number_returns_value(self):
+ """Ein einzelner Wert soll zurückgegeben werden"""
+ self.assertEqual(self.calculator.add("1"), 1)
+
+ def test_two_numbers_return_sum(self):
+ """Zwei Zahlen sollen summiert werden"""
+ self.assertEqual(self.calculator.add("1,2"), 3)
+
+ def test_add_multiple_numbers(self):
+ """Feature 2: Mehrere Zahlen summieren"""
+ self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)
+
+ def test_add_numbers_with_newlines(self):
+ """Feature 3: Zeilenumbrüche als Trennzeichen"""
+ self.assertEqual(self.calculator.add("1\n2\n3"), 6)
+
+ def test_add_negative_numbers(self):
+ """Feature 4: Negative Zahlen sollen Fehler werfen"""
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1,2,-3")
+ self.assertEqual(str(e.exception), "Negative numbers are not allowed: -1, -3")
+
+ def test_add_numbers_with_custom_delimiter(self):
+ """Feature 5: Benutzerdefiniertes Trennzeichen"""
+ self.assertEqual(self.calculator.add("//;\n1;2;3"), 6)
+
+ def test_add_numbers_with_custom_delimiter_different_symbol(self):
+ """Feature 5: Benutzerdefiniertes Trennzeichen mit anderem Symbol"""
+ self.assertEqual(self.calculator.add("//#\n4#5#6"), 15)
+
+ def test_custom_delimiter_with_multiple_numbers(self):
+ """
+ Kombinierter Test für:
+ feature 5 und feature 2
+ Erwartet wird die korrekte Addition von sechs durch ein benutzerdefiniertes Zeichen getrennten Zahlen.
+ """
+ self.assertEqual(self.calculator.add("//:\n1:2:3:4:5:6"), 21)
+
+ def test_add_numbers_greater_than_1000(self):
+ """Feature6 test"""
+ self.assertEqual(self.calculator.add("1,1001,2,3"), 6)
+
+ def test_add_numbers_with_newlines_and_ignore_above_1000(self):
+ """Feature 3 und 6 test Zeilenumbruch als trenner, Zahlen>1000 ignorieren"""
+ self.assertEqual(self.calculator.add("1\n2\n1000\n1001"), 1003)
+
+ def test_add_numbers_with_custom_delimiter_long_length(self):
+ """Benutzerdefinierte Trennzeichen beliebig lang """
+ self.assertEqual(self.calculator.add("//[***]\n1***2***3"), 6)
+
+ def test_custom_long_delimiter_with_large_number_ignored(self):
+ """FEature 6 und 7 test Benutzerdefinierte Delimiter Länge und zahl über 1000 wird ignoriert"""
+ self.assertEqual(self.calculator.add("//[***]\n1***1001***2"), 3)
+
+ def test_custom_long_delimiter_with_negative_numbers(self):
+ """Feature 4 und 7: Benutzerdefinierter Delimiter beliebiger Länge + negative Zahlen"""
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("//[***]\n1***-2***3***-4")
+ self.assertEqual(str(e.exception), "Negative numbers are not allowed: -2, -4")
+
+
+
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/Other/SerchimoMarvin_2/your_calculator.py b/Other/SerchimoMarvin_2/your_calculator.py
index 7fcb66865b36d85578cbb6b48589f0f729826113..eee47dcbc6fb8ad5a06bf057032edbbb82705f91 100644
--- a/Other/SerchimoMarvin_2/your_calculator.py
+++ b/Other/SerchimoMarvin_2/your_calculator.py
@@ -1,8 +1,9 @@
#Meine Implementierungen auf Testfälle anderer Studierenden testen: StringCalculator
-import re
+
import unittest
from stringCalculator import StringCalculator
+from stringCalculator import IStringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -13,7 +14,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string_returns_zero(self):
"""Feature 1: Leerer String soll 0 ergeben"""
diff --git a/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc
index 2075e23bed85e561a84eea481d9e4a3faf3ec4a0..95ac742fff298ee9d4b7911398f53bd26a396db8 100644
Binary files a/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc and b/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc differ
diff --git a/Other/WeishauptOrlando_2/my_calculator.py b/Other/WeishauptOrlando_2/my_calculator.py
index 6dd72eb37d3fd63b7581347117478a4fe1bb997a..577912218dcbac21ad87b2ac5d90e839ebe6ff22 100644
--- a/Other/WeishauptOrlando_2/my_calculator.py
+++ b/Other/WeishauptOrlando_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von WeishauptOrlando auf meinen Testfälle: StringCalculator
import unittest
-
+from src.interfaces import IStringCalculator
from src.string_calculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc b/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc
index 6219bfc375082ce2fd1f73bcfd756ebca8b34d4b..58e113c36227bb8ef2a40cf10efecfa8c4562fd1 100644
Binary files a/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc and b/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc differ
diff --git a/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc b/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc
index 3598fbabdabad4ddd589f69bedaf1572f553b5e0..425b6d2c856c6a059a603abc18addc47796850a6 100644
Binary files a/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc and b/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc differ
diff --git a/Other/WeishauptOrlando_2/src/calculator.py b/Other/WeishauptOrlando_2/src/calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4b478561c819a9985b2e7466e9a3ad0cc363e1c
--- /dev/null
+++ b/Other/WeishauptOrlando_2/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_2/src/interfaces.py b/Other/WeishauptOrlando_2/src/interfaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..be069d6d910a5d5c44d8c083ec4429cfaac516b6
--- /dev/null
+++ b/Other/WeishauptOrlando_2/src/interfaces.py
@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+# Definition des Interfaces für den StringCalculator
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ """
+ Addiert beliebig viele Zahlen, die durch Kommas getrennt sind.
+ Leere oder nur aus Leerzeichen bestehende Einträge werden ignoriert.
+
+ :param numbers: String mit Zahlen (z.B. "1,2,3")
+ :return: Summe der Zahlen als int
+ """
+ pass
+
+class ICounter(ABC):
+ @abstractmethod
+ def count_ed(self, s: str) -> int:
+ """Zählt die Buchstaben 'E' und 'D' in einem String (Case-Insensitive)."""
+ pass
+class IRomanConverter(ABC):
+ @abstractmethod
+ def roman_to_int(self, s: str) -> int:
+ """Konvertiert eine römische Zahl (String) in eine Dezimalzahl."""
+ pass
+
+class ICalculator(ABC):
+ @abstractmethod
+ def calculate(self, expression: str) -> float:
+ pass
\ No newline at end of file
diff --git a/Other/WeishauptOrlando_2/src/string_calculator.py b/Other/WeishauptOrlando_2/src/string_calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cf5afb7e3a7d14a721875024c6bbf1678e6ddb2
--- /dev/null
+++ b/Other/WeishauptOrlando_2/src/string_calculator.py
@@ -0,0 +1,61 @@
+# Implementierung von IStringCalculator
+
+from src.interfaces import IStringCalculator
+
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+ """
+ Addiert beliebig viele Zahlen, getrennt durch Kommas, Zeilenumbrüche
+ oder einen benutzerdefinierten Delimiter.
+ Leere oder whitespace-only Einträge werden ignoriert.
+
+ Beispiele:
+ - "" → 0
+ - "1" → 1
+ - "1,2" → 3
+ - "1,2,3,4,5" → 15
+ - "1,,2" → 3
+ - "1, ,2" → 3
+ - ",,1,,2,,," → 3
+
+ :param numbers: Zahlen als String, getrennt durch Komma
+ :return: Summe der gültigen Zahlen als int
+ """
+ if not numbers:
+ return 0
+
+ delimiter = ","
+
+
+ if numbers.startswith("//"):
+ header, numbers = numbers.split("\n", 1)
+
+ # Mehrzeichen-Delimiter: z. B. //[***]
+ if header.startswith("//[") and header.endswith("]"):
+ delimiter = header[3:-1] # Extrahiere z. B. "***"
+ else:
+ delimiter = header[2:] # Einzeichen-Delimiter
+
+ # Ersetze \n durch Komma (Standard)
+ numbers = numbers.replace("\n", ",")
+
+ # Delimiter ersetzen durch Komma (evtl. mehrere Zeichen)
+ numbers = numbers.replace(delimiter, ",")
+
+ number_list = numbers.split(",")
+
+ # Ignoriere leere oder whitespace-only Einträge
+ cleaned_numbers = [
+ int(n.strip()) for n in number_list if n.strip() != ""
+ ]
+
+ # Negativ-Prüfung
+ negatives = [n for n in cleaned_numbers if n < 0]
+ if negatives:
+ raise ValueError(f"negatives not allowed: {', '.join(map(str, negatives))}")
+
+ # Zahlen > 1000 ignorieren
+ cleaned_numbers = [n for n in cleaned_numbers if n <= 1000]
+
+ return sum(cleaned_numbers)
\ No newline at end of file
diff --git a/Other/WeishauptOrlando_2/tests/TestCount_ED.py b/Other/WeishauptOrlando_2/tests/TestCount_ED.py
new file mode 100644
index 0000000000000000000000000000000000000000..152bccd1cb4dff5df43c1c368fea2de123bfc632
--- /dev/null
+++ b/Other/WeishauptOrlando_2/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_2/tests/__init__.py b/Other/WeishauptOrlando_2/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Other/WeishauptOrlando_2/tests/test_calculator.py b/Other/WeishauptOrlando_2/tests/test_calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0b7b0393dfd8f53fef333cecd5af0a368c3518c
--- /dev/null
+++ b/Other/WeishauptOrlando_2/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_2/tests/test_roman.py b/Other/WeishauptOrlando_2/tests/test_roman.py
new file mode 100644
index 0000000000000000000000000000000000000000..30cbabf8e6517f5fdcb4741df4389df09b0d3817
--- /dev/null
+++ b/Other/WeishauptOrlando_2/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/Other/WeishauptOrlando_2/tests/test_string_calculator.py b/Other/WeishauptOrlando_2/tests/test_string_calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9420c04783cbe6fe8d8c40d0caea43d541e054e
--- /dev/null
+++ b/Other/WeishauptOrlando_2/tests/test_string_calculator.py
@@ -0,0 +1,113 @@
+# Testfälle add(numbers: str) -> int – StringCalculator
+
+# 1. Leerer String
+# Eingabe: "" → Erwartete Ausgabe: 0
+
+# 2. Einzelne Zahl
+# Eingabe: "1" → Erwartete Ausgabe: 1
+
+# 3. Zwei Zahlen, getrennt durch Komma
+# Eingabe: "1,2" → Erwartete Ausgabe: 3
+
+# 4. Mehr als zwei Zahlen (beliebig viele erlaubt)
+# Eingabe: "1,2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2,3,4,5" → Erwartete Ausgabe: 15
+
+# 5. Leere Einträge ignorieren
+# Eingabe: "1,,2" → Erwartete Ausgabe: 3
+# Eingabe: "1, ,2" → Erwartete Ausgabe: 3
+# Eingabe: ",,1,,2,,," → Erwartete Ausgabe: 3
+
+# 6. Zeilenumbrüche als Trennzeichen erlauben
+# Eingabe: "1\n2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2\n3" → Erwartete Ausgabe: 6
+# Eingabe: "1\n2\n3" → Erwartete Ausgabe: 6
+
+# 8. Negative Zahlen → Exception mit allen negativen Werten
+# Eingabe: "1,-2" → Exception mit Message "negatives not allowed: -2"
+# Eingabe: "-1,-2,3" → Exception mit Message "negatives not allowed: -1, -2"
+
+# 9. Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+# Eingabe: "//;\n1;2" → 3
+# Eingabe: "//|\n4|5|6" → 15
+# Eingabe: "//_\n7_8_9" → 24
+
+# 10. Zahlen größer als 1000 ignorieren
+# Eingabe: "2,1001" → 2
+# Eingabe: "1000,1" → 1001 (1000 zählt noch mit)
+# Eingabe: "1234,1001,3" → 3
+
+# 11. Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+# Eingabe: "//[***]\n1***2***3" → 6
+# Eingabe: "//[abc]\n4abc5abc6" → 15
+# Eingabe: "//[+]\n1+2+3" → 6
+
+import unittest
+from src.string_calculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ # Vor jedem Test wird eine Instanz des Calculators erstellt
+ self.calc = StringCalculator()
+
+ def test_add_empty_string(self):
+ # Leerer String → 0
+ self.assertEqual(self.calc.add(""), 0)
+
+ def test_add_single_number(self):
+ # Ein einzelner Wert → int
+ self.assertEqual(self.calc.add("1"), 1)
+
+ def test_add_two_numbers(self):
+ # Zwei Zahlen → Summe
+ self.assertEqual(self.calc.add("1,2"), 3)
+
+ def test_add_multiple_numbers(self):
+ # Mehr als zwei Zahlen → Summe
+ self.assertEqual(self.calc.add("1,2,3"), 6)
+ self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
+
+ def test_add_ignores_empty_entries(self):
+ # Leere Einträge ignorieren → Summe
+ self.assertEqual(self.calc.add("1,,2"), 3)
+ self.assertEqual(self.calc.add("1, ,2"), 3)
+ self.assertEqual(self.calc.add(",,1,,2,,,"), 3)
+
+ def test_add_with_newlines_between_numbers(self):
+ # Zeilenumbrüche als Trennzeichen erlauben → Summe
+ self.assertEqual(self.calc.add("1\n2,3"), 6)
+ self.assertEqual(self.calc.add("1,2\n3"), 6)
+ self.assertEqual(self.calc.add("1\n2\n3"), 6)
+
+ def test_add_raises_exception_on_negative_number(self):
+ # Negative Zahlen → Exception mit allen negativen Werten
+ with self.assertRaises(ValueError) as context:
+ self.calc.add("1,-2")
+ self.assertIn("negatives not allowed: -2", str(context.exception))
+
+ def test_add_raises_exception_on_multiple_negatives(self):
+ # Negative Zahlen → Exception mit allen negativen Werten
+ with self.assertRaises(ValueError) as context:
+ self.calc.add("-1,-2,3")
+ self.assertIn("negatives not allowed: -1, -2", str(context.exception))
+
+ def test_add_with_custom_delimiter(self):
+ # Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+ self.assertEqual(self.calc.add("//;\n1;2"), 3)
+ self.assertEqual(self.calc.add("//|\n4|5|6"), 15)
+ self.assertEqual(self.calc.add("//_\n7_8_9"), 24)
+
+ def test_add_ignores_numbers_greater_than_1000(self):
+ # Zahlen größer als 1000 ignorieren
+ self.assertEqual(self.calc.add("2,1001"), 2)
+ self.assertEqual(self.calc.add("1000,1"), 1001)
+ self.assertEqual(self.calc.add("1234,1001,3"), 3)
+
+ def test_add_with_multi_char_delimiter(self):
+ # Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+ self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
+ self.assertEqual(self.calc.add("//[abc]\n4abc5abc6"), 15)
+ self.assertEqual(self.calc.add("//[+]\n1+2+3"), 6)
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Other/report.md b/Other/report.md
index af401cbb39fc134e08ef7a044c056cbed82cf26f..75514ddee1f1df6b6e79f3d1680eb0bb4c8fa6c9 100644
--- a/Other/report.md
+++ b/Other/report.md
@@ -22,3 +22,26 @@ Testfälle anderer Studierender auf meine Implementierung: RomanNumberConverter
|SerchimoMarvin | NaN | - |
|WeishauptOrlando | No | 4x AttributeError: 'RomanNumber' object has no attribute 'roman_to_int' |
+Implementierungen anderer Studierender auf meine Testfälle: StringCalculator
+
+| Name | Interface break | Failed Testcases |
+|------------------|------------------|--------------------------------------------------|
+|AliciMuhamed | Yes | SyntaxError: invalid syntax (gespeicherte DateiName) |
+|BerishaAlma | No | None |
+|GotsisWasili | No | FAIL: test_multiple_negative_numbers // FAIL: test_negative_number |
+|PikkemaatLasse | No | FAIL: test_add_single_negative_number // FAIL: test_add_multiple_negative_numbers // ERROR: test_add_with_custom_delimiter_multiple_characters |
+|RafehDaniel | No | FAIL: test_negative_number // FAIL: test_multiple_negative_numbers |
+|SerchimoMarvin | No | FAIL: test_custom_long_delimiter_with_negative_numbers // FAIL: test_add_negative_numbers // ERROR: test_custom_long_delimiter_with_large_number_ignored // ERROR: test_add_numbers_with_custom_delimiter_long_length |
+|WeishauptOrlando | No | 2x FAIL: test_negative_number |
+
+Meine Implementierung auf Testfälle anderer Studierender: StringCalculator
+
+| Name | Interface break | Failed Testcases |
+|------------------|------------------|--------------------------------------------------|
+|AliciMuhamed | No | FAIL: test_negative_number_exception // FAIL: test_multiple_negative_numbers_exception // FAIL: test_add_numbers_greater_1000_and_minus // ERROR: test_custom_delimiter // ERROR: test_custom_del2 // ERROR: test_custom_del // ERROR: test_add_numbers_with_custom_delimiter |
+|BerishaAlma | No | None |
+|GotsisWasili | Yes | FAIL: test_add_negative_numbers / FAIL: test_add_exception / ERROR: test_implements_interface / ERROR: test_delimiters_of_any_length2 / ERROR: test_delimiters_of_any_length |
+|PikkemaatLasse | No | FAIL: test_negative_number // FAIL: test_multiple_negative_numbers |
+|RafehDaniel | No | ERROR: test_one_number_with_empty_string // ERROR: test_negative_with_positive// ERROR: test_negativeValues // ERROR: test_multidelimiter // ERROR: test_multi_negative // ERROR: test_mixture // ERROR: test_handleLetter // ERROR: test_handleFloat // ERROR: test_empty_text |
+|SerchimoMarvin | Yes | ModuleNotFoundError: No module named 'feature7' |
+|WeishauptOrlando | No | FAIL: test_add_raises_exception_on_negative_number // 2x FAIL: test_negative_number // ERROR: test_add_ignores_empty_entries // ERROR: test_add_with_multi_char_delimiter |
\ No newline at end of file