From 012b2f6c36bea415abda988ac24bafc02dbc1da2 Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sun, 6 Apr 2025 03:56:06 +0200
Subject: [PATCH] Alle getestetten Datein stringCalculator
---
Other/GotsisWasili_2/TDD_StringCalculator.py | 110 ++++++++++++++++++
.../__pycache__/TDD_StringCalculator.py | Bin 6235 -> 0 bytes
.../stringCalculator.cpython-312.pyc | Bin 6649 -> 0 bytes
Other/GotsisWasili_2/my_calculator.py | 58 +++++++++
Other/GotsisWasili_2/stringCalculator.py | 88 ++++++++++++++
Other/GotsisWasili_2/your_calculator.py | 61 ++++++++++
6 files changed, 317 insertions(+)
create mode 100644 Other/GotsisWasili_2/TDD_StringCalculator.py
delete mode 100644 Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.py
delete mode 100644 Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc
create mode 100644 Other/GotsisWasili_2/my_calculator.py
create mode 100644 Other/GotsisWasili_2/stringCalculator.py
create mode 100644 Other/GotsisWasili_2/your_calculator.py
diff --git a/Other/GotsisWasili_2/TDD_StringCalculator.py b/Other/GotsisWasili_2/TDD_StringCalculator.py
new file mode 100644
index 0000000..ab815fa
--- /dev/null
+++ b/Other/GotsisWasili_2/TDD_StringCalculator.py
@@ -0,0 +1,110 @@
+#Bei Eingabe des Strings "" liefert die Funktion 0
+#Bei Eingabe des Strings "1" liefert die Funktion 1
+#Bei Eingabe des Strings "1,2" liefert die Funktion 3
+#Bei Eingabe des Strings "1,2,3,4,5,6,7" liefert die Funkktion 28
+#Bei Eingabe des Strings "1\n2,3,4" liefert die Funkktion 10
+#Bei Eingabe des Strings "-5" liefert die Funkktion eine exception mit [“negatives not allowed†-5]
+#Bei Eingabe des Strings "-5,-2,-2" liefert die Funkktion eine exception mit [“negatives not allowed†-5,-2,-2]
+#Bei Eingabe des Strings "//;\n1;2" liefert die Funktion 3 wobei das Standard-Trennzeichen';' ist.
+#Bei Eingabe des Strings "2,1001" liefert die Funktion 2
+#Bei Eingabe des Strings "2,10022\n6" liefert die Funktion 8
+#Bei Eingabe des Strings "//[***]\n1***2***3" mit dem Trennzeichen '***' liefert die Funktion 6
+#Bei Eingabe des Strings "//[*+*+*]\n1*+*+*2*+*+*3*+*+*220" mit dem Trennzeichen '***' liefert die Funktion 226
+
+import unittest
+from abc import ABC, abstractmethod
+
+#Interface für StringCalculator
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers:str) -> int:
+ pass
+
+#Implementierung der Calculator Klasse
+class StringCalculator(IStringCalculator):
+ def add(self, numbers:str) -> int:
+ if numbers == "":
+ return 0
+
+ #Prüfen, ob ein benutzerdefiniertes Trennzeichen definiert wurde
+
+ if numbers.startswith("//"):
+ delimiter_end_index = numbers.index("\n") #Zeilenumbruchs Position finden
+ delimiter = numbers[2:delimiter_end_index] # Trennzeichen, also alles zwischen "//" und "\n" extrahieren
+
+ if delimiter.startswith("[") and delimiter.endswith("]"):
+ delimiter = delimiter[1:-1] # "[" und "]" entfernen
+
+ numbers = numbers[delimiter_end_index + 1:] #Zahlen nach "\n" extrahieren
+ numbers = numbers.replace(delimiter,",") #Benutzerdefiniertes Trennzeichen durch "," ersetzen
+
+ #Zeilenumbrüche ebenfals durch "," ersetzen
+ numbers = numbers.replace("\n",",")
+
+ # String anhand von Kommas splitten, eine Liste der einzelnen Zahlen(in str) erzeugen und in Int umwandeln -> Ergebnis wäre z.B. bei add("1\n2,3,4") -> [1,2,3,4]
+ num_list = list(map(int, numbers.split(",",)))
+
+ #Prüfung auf negative Zahlen
+ negatives = [n for n in num_list if n<0]
+ if negatives:
+ raise ValueError(f"negatives not allowed: {','.join(map(str, negatives))}") #Alle negativen Zahlen durch Kommas in getrennte Strings darstellen
+
+ #Zahlen größer als 1000 aus Liste entfernen
+ num_list = [n for n in num_list if n <= 1000]
+
+ return sum(num_list) #Summe berechnen (bei einer Zahln wird immernoch dieselbe Zahl ausgegeben)
+
+
+#mplementierung der Testklasse für StringCalculator
+class TestStringCalculator(unittest.TestCase):
+ def test_add_empty(self):
+ c = StringCalculator()
+ self.assertEqual(c.add(""), 0)
+
+ def test_add_one_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1"), 1)
+
+ def test_add_two_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1,2"), 3)
+
+ def test_add_multiple_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1,2,3,4,5,6,7"), 28)
+
+ def test_add_new_lines(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1\n2,3,4"), 10)
+
+ def test_add_exception(self):
+ c = StringCalculator()
+ with self.assertRaises(ValueError) as context:
+ c.add("-5")
+ self.assertEqual(str(context.exception), "negatives not allowed: -5")
+
+ def test_add_negative_numbers(self):
+ c = StringCalculator()
+ with self.assertRaises(ValueError) as context:
+ c.add("-5,-2,-2")
+ self.assertEqual(str(context.exception), "negatives not allowed: -5,-2,-2")
+
+ def test_add_different_delimiters(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//;\n1;2"), 3)
+
+ def test_add_numbers_greater_than_1000(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("2,1001"),2)
+ self.assertEqual(c.add("2,10022\n6"),8)
+
+ def test_delimiters_of_any_length(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//[***]\n1***2***3"), 6)
+
+ def test_delimiters_of_any_length2(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//[*+*+*]\n1*+*+*2*+*+*3*+*+*220"), 226)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.py b/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.py
deleted file mode 100644
index 30cde4b9279a6ce277f38bbb9f1eb96fa171b33b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6235
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
diff --git a/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc
deleted file mode 100644
index 58a2ceb3da7d4787f3cae3a243acdaccab98a25d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6649
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
Xm)NTN=YMeVdl%oow89X!UKi%S#xa0x
diff --git a/Other/GotsisWasili_2/my_calculator.py b/Other/GotsisWasili_2/my_calculator.py
new file mode 100644
index 0000000..ab49b59
--- /dev/null
+++ b/Other/GotsisWasili_2/my_calculator.py
@@ -0,0 +1,58 @@
+#Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
+import unittest
+
+from TDD_StringCalculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+
+ def test_implements_interface(self):
+ self.assertIsInstance(self.calculator, StringCalculator)
+
+ 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/stringCalculator.py b/Other/GotsisWasili_2/stringCalculator.py
new file mode 100644
index 0000000..bd21dc8
--- /dev/null
+++ b/Other/GotsisWasili_2/stringCalculator.py
@@ -0,0 +1,88 @@
+from abc import ABC, abstractmethod
+import unittest
+
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ pass
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+ if not numbers:
+ return 0
+
+ # Überprüfe, ob ein benutzerdefiniertes Trennzeichen angegeben ist
+ if numbers.startswith("//"):
+ delimiter_line_end = numbers.find("\n")
+ delimiter = numbers[2:delimiter_line_end] # Extrahiere das Trennzeichen
+ numbers = numbers[delimiter_line_end + 1:] # Entferne die erste Zeile mit dem Trennzeichen
+ else:
+ delimiter = ',' # Standard-Trennzeichen ist Komma
+
+ # Ersetze alle Vorkommen des Trennzeichens und teile die Eingabe
+ numbers = numbers.replace("\n", delimiter)
+ nums = numbers.split(delimiter)
+
+ # Filtere alle Zahlen, die größer als 1000 sind
+ nums = [int(num) for num in nums if int(num) <= 1000]
+
+ # Prüfe auf negative Zahlen
+ negatives = [num for num in nums if num < 0]
+
+ if negatives:
+ # Wenn negative Zahlen vorhanden sind, werfe eine Ausnahme
+ raise ValueError(f"Negatives not allowed: {', '.join(map(str, negatives))}")
+
+ # Berechne die Summe der Zahlen, die <= 1000 sind
+ return sum(nums)
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+
+ 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/your_calculator.py b/Other/GotsisWasili_2/your_calculator.py
new file mode 100644
index 0000000..9742055
--- /dev/null
+++ b/Other/GotsisWasili_2/your_calculator.py
@@ -0,0 +1,61 @@
+import unittest
+from stringCalculator import StringCalculator
+
+#mplementierung der Testklasse für StringCalculator
+class TestStringCalculator(unittest.TestCase):
+
+ def test_implements_interface(self):
+ c = StringCalculator()
+ self.assertIsInstance(self.c, StringCalculator)
+
+ def test_add_empty(self):
+ c = StringCalculator()
+ self.assertEqual(c.add(""), 0)
+
+ def test_add_one_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1"), 1)
+
+ def test_add_two_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1,2"), 3)
+
+ def test_add_multiple_string(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1,2,3,4,5,6,7"), 28)
+
+ def test_add_new_lines(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("1\n2,3,4"), 10)
+
+ def test_add_exception(self):
+ c = StringCalculator()
+ with self.assertRaises(ValueError) as context:
+ c.add("-5")
+ self.assertEqual(str(context.exception), "negatives not allowed: -5")
+
+ def test_add_negative_numbers(self):
+ c = StringCalculator()
+ with self.assertRaises(ValueError) as context:
+ c.add("-5,-2,-2")
+ self.assertEqual(str(context.exception), "negatives not allowed: -5,-2,-2")
+
+ def test_add_different_delimiters(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//;\n1;2"), 3)
+
+ def test_add_numbers_greater_than_1000(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("2,1001"),2)
+ self.assertEqual(c.add("2,10022\n6"),8)
+
+ def test_delimiters_of_any_length(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//[***]\n1***2***3"), 6)
+
+ def test_delimiters_of_any_length2(self):
+ c = StringCalculator()
+ self.assertEqual(c.add("//[*+*+*]\n1*+*+*2*+*+*3*+*+*220"), 226)
+
+if __name__ == "__main__":
+ unittest.main()
--
GitLab