From 7774f6dc1be3948504852046c7040bd514af0c82 Mon Sep 17 00:00:00 2001
From: DaniRafeh28 <daniel.rafeh@student.reutlingen-university.de>
Date: Fri, 4 Apr 2025 18:07:23 +0200
Subject: [PATCH] 8 errors detected -- Report Table adjusted
---
.../other/AliciMuhamed/StringCalculator.py | 136 ++++++++++++++++++
.../StringCalculator.cpython-312.pyc | Bin 0 -> 9232 bytes
Project_Test/other/BerishaAlma/Feature6.py | 94 ++++++++++++
.../GotsisWasilios/TDD_StringCalculator.py | 110 ++++++++++++++
.../other/PikkemaatLasse/stringcalculator.py | 100 +++++++++++++
Project_Test/other/SerchimoMarvin/feature7.py | 127 ++++++++++++++++
.../WeishauptOrlando/string_calculator.py | 120 ++++++++++++++++
Project_Test/other/YildirimHatice/feature6.py | 94 ++++++++++++
Project_Test/report.md | 9 ++
.../stringCalculator.py | 4 +-
10 files changed, 792 insertions(+), 2 deletions(-)
create mode 100644 Project_Test/other/AliciMuhamed/StringCalculator.py
create mode 100644 Project_Test/other/AliciMuhamed/__pycache__/StringCalculator.cpython-312.pyc
create mode 100644 Project_Test/other/BerishaAlma/Feature6.py
create mode 100644 Project_Test/other/GotsisWasilios/TDD_StringCalculator.py
create mode 100644 Project_Test/other/PikkemaatLasse/stringcalculator.py
create mode 100644 Project_Test/other/SerchimoMarvin/feature7.py
create mode 100644 Project_Test/other/WeishauptOrlando/string_calculator.py
create mode 100644 Project_Test/other/YildirimHatice/feature6.py
create mode 100644 Project_Test/report.md
rename stringCalculator.py => Project_Test/stringCalculator.py (98%)
diff --git a/Project_Test/other/AliciMuhamed/StringCalculator.py b/Project_Test/other/AliciMuhamed/StringCalculator.py
new file mode 100644
index 0000000..fc44a5a
--- /dev/null
+++ b/Project_Test/other/AliciMuhamed/StringCalculator.py
@@ -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/Project_Test/other/AliciMuhamed/__pycache__/StringCalculator.cpython-312.pyc b/Project_Test/other/AliciMuhamed/__pycache__/StringCalculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..117038d194d60d65df21c8d25923b9ea6824b32a
GIT binary patch
literal 9232
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
bUr?KpblLc^U!MH=$zPm;&z$sT?T!BpUuIa%
literal 0
HcmV?d00001
diff --git a/Project_Test/other/BerishaAlma/Feature6.py b/Project_Test/other/BerishaAlma/Feature6.py
new file mode 100644
index 0000000..0f35297
--- /dev/null
+++ b/Project_Test/other/BerishaAlma/Feature6.py
@@ -0,0 +1,94 @@
+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, wenn keine Zeile mit dem Trennzeichen vorhanden ist
+
+ # 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)
+
+ def test_long_delimiter(self):
+ self.assertEqual(self.calculator.add("//[***]\n1***2***3"), 6)
+
+ def test_long_delimiter_with_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("//[---]\n1---2---3---4"), 10)
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Project_Test/other/GotsisWasilios/TDD_StringCalculator.py b/Project_Test/other/GotsisWasilios/TDD_StringCalculator.py
new file mode 100644
index 0000000..ab815fa
--- /dev/null
+++ b/Project_Test/other/GotsisWasilios/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/Project_Test/other/PikkemaatLasse/stringcalculator.py b/Project_Test/other/PikkemaatLasse/stringcalculator.py
new file mode 100644
index 0000000..d4f0263
--- /dev/null
+++ b/Project_Test/other/PikkemaatLasse/stringcalculator.py
@@ -0,0 +1,100 @@
+import re
+
+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:
+ 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)
+
+
+import unittest
+
+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/Project_Test/other/SerchimoMarvin/feature7.py b/Project_Test/other/SerchimoMarvin/feature7.py
new file mode 100644
index 0000000..92de925
--- /dev/null
+++ b/Project_Test/other/SerchimoMarvin/feature7.py
@@ -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/Project_Test/other/WeishauptOrlando/string_calculator.py b/Project_Test/other/WeishauptOrlando/string_calculator.py
new file mode 100644
index 0000000..cf19738
--- /dev/null
+++ b/Project_Test/other/WeishauptOrlando/string_calculator.py
@@ -0,0 +1,120 @@
+# Implementierung von IStringCalculator
+from abc import ABC, abstractmethod
+
+# Definition des Interfaces für den StringCalculator
+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
+
+ 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)
+
+import unittest
+
+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/Project_Test/other/YildirimHatice/feature6.py b/Project_Test/other/YildirimHatice/feature6.py
new file mode 100644
index 0000000..949c324
--- /dev/null
+++ b/Project_Test/other/YildirimHatice/feature6.py
@@ -0,0 +1,94 @@
+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, wenn keine Zeile mit dem Trennzeichen vorhanden ist
+
+ # 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)
+
+ def test_long_delimiter(self):
+ self.assertEqual(self.calculator.add("//[***]\n1***2***3"), 6)
+
+ def test_long_delimiter_with_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("//[---]\n1---2---3---4"), 10)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Project_Test/report.md b/Project_Test/report.md
new file mode 100644
index 0000000..241a0a5
--- /dev/null
+++ b/Project_Test/report.md
@@ -0,0 +1,9 @@
+| Name | Interface break | Failed Testcases |
+|------------------|-----------------|------------------|
+| AliciMuhamed | yes (8) | none |
+| BerishaAlma | | |
+| GotsisWasilios | | |
+| PikkemaatLasse | | |
+| YildirimHatice | | |
+| WeishauptOrlando | | |
+| SerchimoMarvin | | |
\ No newline at end of file
diff --git a/stringCalculator.py b/Project_Test/stringCalculator.py
similarity index 98%
rename from stringCalculator.py
rename to Project_Test/stringCalculator.py
index 232cb01..3ef0867 100644
--- a/stringCalculator.py
+++ b/Project_Test/stringCalculator.py
@@ -19,7 +19,7 @@
import unittest
from abc import ABC, abstractmethod
-
+from other.AliciMuhamed.StringCalculator import StringCalculator as MomoCalc
class IStringCalculator(ABC):
@abstractmethod
@@ -93,7 +93,7 @@ class StringCalculator(IStringCalculator):
class TestStringCalculator(unittest.TestCase):
def setUp(self):
- self.c = StringCalculator()
+ self.c = MomoCalc()
def test_empty(self):
res = self.c.add("")
--
GitLab