diff --git a/Feature1.py b/Feature1.py
deleted file mode 100644
index c2a76ece9263d47a3629586f6def03e775763812..0000000000000000000000000000000000000000
--- a/Feature1.py
+++ /dev/null
@@ -1,32 +0,0 @@
-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
- return sum(map(int, numbers.split(',')))
-
-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)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/Feature2.py b/Feature2.py
deleted file mode 100644
index 313c83859224784eac53ffb5958c3e0c872ee112..0000000000000000000000000000000000000000
--- a/Feature2.py
+++ /dev/null
@@ -1,41 +0,0 @@
-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
- # Ersetze Zeilenumbrüche durch Kommas und teile die Eingabe nach Kommas
- numbers = numbers.replace("\n", ",")
- return sum(map(int, numbers.split(',')))
-
-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)
-
-if __name__ == "__main__":
- unittest.main()
-
diff --git a/Feature3.py b/Feature3.py
deleted file mode 100644
index e97fdae58521764c186681c72bcc831a5c676654..0000000000000000000000000000000000000000
--- a/Feature3.py
+++ /dev/null
@@ -1,61 +0,0 @@
-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
-
- # Ersetze Zeilenumbrüche durch Kommas und teile die Eingabe nach Kommas
- numbers = numbers.replace("\n", ",")
-
- # Splitte die Zahlen und prüfe auf negative Zahlen
- nums = numbers.split(',')
- negatives = [num for num in nums if int(num) < 0]
-
- if negatives:
- # Wenn negative Zahlen vorhanden sind, werfe eine Ausnahme
- raise ValueError(f"Negatives not allowed: {', '.join(negatives)}")
-
- # Berechne die Summe der positiven Zahlen
- return sum(map(int, 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")
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/Feature4.py b/Feature4.py
deleted file mode 100644
index 0a5f7530f0f7134fc3f8806f54246d051172a010..0000000000000000000000000000000000000000
--- a/Feature4.py
+++ /dev/null
@@ -1,80 +0,0 @@
-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)
-
- # Prüfe auf negative Zahlen
- negatives = [num for num in nums if int(num) < 0]
-
- if negatives:
- # Wenn negative Zahlen vorhanden sind, werfe eine Ausnahme
- raise ValueError(f"Negatives not allowed: {', '.join(negatives)}")
-
- # Berechne die Summe der positiven Zahlen
- return sum(map(int, 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)
-
-if __name__ == "__main__":
- unittest.main()
-
diff --git a/Feature5.py b/Feature5.py
deleted file mode 100644
index 4bb39d4e56abfa1a9bf0d19de26b6dd8a927de04..0000000000000000000000000000000000000000
--- a/Feature5.py
+++ /dev/null
@@ -1,88 +0,0 @@
-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)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/Feature6.py b/Feature6.py
deleted file mode 100644
index 0f35297ebc07e1bd3d13bb70713f3ecbe5b9f33a..0000000000000000000000000000000000000000
--- a/Feature6.py
+++ /dev/null
@@ -1,94 +0,0 @@
-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/other/student1/Calculator.py b/other/student1/Calculator.py
deleted file mode 100644
index ddc60c6109f967411472c4925d9d525eed3cc3f5..0000000000000000000000000000000000000000
--- a/other/student1/Calculator.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import unittest
-from abc import ABC, abstractmethod #Daniel Rafeh
-
-
-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/student1/__pycache__/Calculator.cpython-313.pyc b/other/student1/__pycache__/Calculator.cpython-313.pyc
deleted file mode 100644
index e4e08953a9e4aefe974df4cc26c82e769f8ca559..0000000000000000000000000000000000000000
Binary files a/other/student1/__pycache__/Calculator.cpython-313.pyc and /dev/null differ
diff --git a/other/student2/Calculator.py b/other/student2/Calculator.py
deleted file mode 100644
index 05449ba13777deed95d5ac179974bdaa67a429e6..0000000000000000000000000000000000000000
--- a/other/student2/Calculator.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import unittest
-from abc import ABC, abstractmethod #Wasili
-
-#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()
\ No newline at end of file
diff --git a/other/student2/__pycache__/Calculator.cpython-313.pyc b/other/student2/__pycache__/Calculator.cpython-313.pyc
deleted file mode 100644
index b8ea3ae8c73d007501c8384c94b321840b9e2cad..0000000000000000000000000000000000000000
Binary files a/other/student2/__pycache__/Calculator.cpython-313.pyc and /dev/null differ
diff --git a/other/student3/Calculator.py b/other/student3/Calculator.py
deleted file mode 100644
index e91cd9e91207445dc9afb27a560644ad20fc47c4..0000000000000000000000000000000000000000
--- a/other/student3/Calculator.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import unittest
-import re #Momo
-
-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/student3/__pycache__/Calculator.cpython-313.pyc b/other/student3/__pycache__/Calculator.cpython-313.pyc
deleted file mode 100644
index 1394af73c7b584d4b136e8c64570dba56c2e12b0..0000000000000000000000000000000000000000
Binary files a/other/student3/__pycache__/Calculator.cpython-313.pyc and /dev/null differ
diff --git a/other/student4/Calculator.py b/other/student4/Calculator.py
deleted file mode 100644
index e38e25f62cafc2656eb8bebf8590503fa59bce1f..0000000000000000000000000000000000000000
--- a/other/student4/Calculator.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import re
-import unittest #Marvin
-
-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/student4/__pycache__/Calculator.cpython-313.pyc b/other/student4/__pycache__/Calculator.cpython-313.pyc
deleted file mode 100644
index 12e1f492b290095e043cc3c3bafdf28c08c709b5..0000000000000000000000000000000000000000
Binary files a/other/student4/__pycache__/Calculator.cpython-313.pyc and /dev/null differ
diff --git a/other/student5/Calculator_combined.py b/other/student5/Calculator_combined.py
deleted file mode 100644
index 09214d2b017291bee4f86a23882b161d83392bd8..0000000000000000000000000000000000000000
--- a/other/student5/Calculator_combined.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from abc import ABC, abstractmethod
-import unittest #Orlandos test kombiniert aus 2 dateien,da fehlerhafte meldung mit scr hat anders nicht geklappt
-
-
-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)
-
- if header.startswith("//[") and header.endswith("]"):
- delimiter = header[3:-1]
- else:
- delimiter = header[2:]
-
- numbers = numbers.replace("\n", ",")
- numbers = numbers.replace(delimiter, ",")
-
- number_list = numbers.split(",")
- cleaned_numbers = [
- int(n.strip()) for n in number_list if n.strip() != ""
- ]
-
- negatives = [n for n in cleaned_numbers if n < 0]
- if negatives:
- raise ValueError(f"negatives not allowed: {', '.join(map(str, negatives))}")
-
- cleaned_numbers = [n for n in cleaned_numbers if n <= 1000]
-
- return sum(cleaned_numbers)
-
-# --- TESTS ---
-class TestStringCalculator(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_add_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_add_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_add_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_add_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
-
- def test_add_ignores_empty_entries(self):
- 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(self):
- 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_negative_number(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("1,-2")
- self.assertIn("negatives not allowed: -2", str(context.exception))
-
- def test_multiple_negative_numbers(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-1,-2,3")
- self.assertIn("negatives not allowed: -1, -2", str(context.exception))
-
- def test_custom_delimiter(self):
- 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_ignores_large_numbers(self):
- 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_multi_char_delimiter(self):
- 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()
diff --git a/other/student5/__pycache__/Calculator_combined.cpython-313.pyc b/other/student5/__pycache__/Calculator_combined.cpython-313.pyc
deleted file mode 100644
index 58da210273e9ccdba83d4985845021ab109a6672..0000000000000000000000000000000000000000
Binary files a/other/student5/__pycache__/Calculator_combined.cpython-313.pyc and /dev/null differ
diff --git a/other/student6/Calculator_combined.py b/other/student6/Calculator_combined.py
deleted file mode 100644
index 35f45319f4da9fd72eda87969d43ecc310165132..0000000000000000000000000000000000000000
--- a/other/student6/Calculator_combined.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from abc import ABC, abstractmethod
-import re
-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
-
- 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)
-
-
-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")
- 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")
- 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")
- self.assertTrue("Ungültiges Format" in 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()
diff --git a/other/student6/__pycache__/Calculator_combined.cpython-313.pyc b/other/student6/__pycache__/Calculator_combined.cpython-313.pyc
deleted file mode 100644
index 63f3b5d384042ba48f47a641fd4dd097ec8a0620..0000000000000000000000000000000000000000
Binary files a/other/student6/__pycache__/Calculator_combined.cpython-313.pyc and /dev/null differ
diff --git a/other/student7/Calculator.py b/other/student7/Calculator.py
deleted file mode 100644
index b525ef2bd0ccd7b507162be34c93ebd9e6c78a55..0000000000000000000000000000000000000000
--- a/other/student7/Calculator.py
+++ /dev/null
@@ -1,88 +0,0 @@
-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()
\ No newline at end of file
diff --git a/other/student7/__pycache__/Calculator.cpython-313.pyc b/other/student7/__pycache__/Calculator.cpython-313.pyc
deleted file mode 100644
index f61d4aee076afc81ec36544859b8b4244ff90ae4..0000000000000000000000000000000000000000
Binary files a/other/student7/__pycache__/Calculator.cpython-313.pyc and /dev/null differ
diff --git a/test_me_on_student1.py b/test_me_on_student1.py
deleted file mode 100644
index fd33f2ffa20c6880594ff61bb29f7a66fb69928b..0000000000000000000000000000000000000000
--- a/test_me_on_student1.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import unittest
-from other.student1.Calculator import StringCalculator # dani
-
-class TestMyCalcOnStudent1(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):
- self.calculator.add("1,-2,3")
-
- def test_multiple_negative_numbers(self):
- with self.assertRaises(ValueError):
- self.calculator.add("1,-2,-3,4")
-
- 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/test_me_on_student2.py b/test_me_on_student2.py
deleted file mode 100644
index 62056a319309a069b18b2a6191c5da8f9d2ddd2f..0000000000000000000000000000000000000000
--- a/test_me_on_student2.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import unittest
-from other.student2.Calculator import StringCalculator #wasili
-
-class TestMeOnStudent2(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
-
- def test_numbers_with_newline(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
-
- def test_numbers_with_multiple_newlines(self):
- self.assertEqual(self.calc.add("1\n2\n3\n4\n5"), 15)
-
- def test_negative_number(self):
- with self.assertRaises(ValueError) as context:
- self.calc.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.calc.add("1,-2,-3,4")
- self.assertEqual(str(context.exception), "negatives not allowed: -2, -3")
-
- def test_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
-
- def test_custom_delimiter_with_newline(self):
- self.assertEqual(self.calc.add("//;\n1;2\n3"), 6)
-
- def test_custom_delimiter_with_multiple_numbers(self):
- self.assertEqual(self.calc.add("//|\n1|2|3|4"), 10)
-
- def test_numbers_greater_than_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
-
- def test_numbers_greater_than_1000_with_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n2;1001"), 2)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_me_on_student3.py b/test_me_on_student3.py
deleted file mode 100644
index 1219fa4b2141def506bef414fd4789500a7a179f..0000000000000000000000000000000000000000
--- a/test_me_on_student3.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import unittest
-from other.student3.Calculator import StringCalculator #momo
-
-class TestMyCasesOnStudent3(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
-
- def test_numbers_with_newline(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
-
- def test_multiple_newlines(self):
- self.assertEqual(self.calc.add("1\n2\n3\n4\n5"), 15)
-
- def test_negative_number(self):
- with self.assertRaises(ValueError) as e:
- self.calc.add("1,-2,3")
- self.assertEqual(str(e.exception), "negatives not allowed: -2")
-
- def test_multiple_negative_numbers(self):
- with self.assertRaises(ValueError) as e:
- self.calc.add("1,-2,-3,4")
- self.assertEqual(str(e.exception), "negatives not allowed: -2,-3")
-
- def test_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
-
- def test_custom_delimiter_with_newline(self):
- self.assertEqual(self.calc.add("//;\n1;2\n3"), 6)
-
- def test_ignore_numbers_over_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
-
- def test_custom_delimiter_any_length(self):
- self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_me_on_student4.py b/test_me_on_student4.py
deleted file mode 100644
index 751d20e4a1c61631ad6bc6a76350756e77a42b7e..0000000000000000000000000000000000000000
--- a/test_me_on_student4.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import unittest
-from other.student4.Calculator import StringCalculator # Marvin
-
-class TestMyCasesOnStudent4(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
-
- def test_numbers_with_newline(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
-
- def test_multiple_newlines(self):
- self.assertEqual(self.calc.add("1\n2\n3\n4\n5"), 15)
-
- def test_negative_number(self):
- with self.assertRaises(ValueError) as e:
- self.calc.add("1,-2,3")
- self.assertEqual(str(e.exception), "Negative numbers are not allowed: -2")
-
- def test_multiple_negative_numbers(self):
- with self.assertRaises(ValueError) as e:
- self.calc.add("1,-2,-3,4")
- self.assertEqual(str(e.exception), "Negative numbers are not allowed: -2, -3")
-
- def test_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
-
- def test_custom_delimiter_with_newline(self):
- self.assertEqual(self.calc.add("//;\n1;2\n3"), 6)
-
- def test_ignore_numbers_over_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
-
- def test_custom_delimiter_any_length(self):
- self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_me_on_student5.py b/test_me_on_student5.py
deleted file mode 100644
index c66995b7216c4da27cf6cea024f9efcb28538678..0000000000000000000000000000000000000000
--- a/test_me_on_student5.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import unittest
-from other.student5.Calculator_combined import StringCalculator #orlando
-
-class TestMeOnStudent5(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_ignores_empty_entries(self):
- self.assertEqual(self.calc.add("1,,2"), 3)
- self.assertEqual(self.calc.add(",,1,,2,,"), 3)
-
- def test_add_multi_char_delimiter(self):
- self.assertEqual(self.calc.add("//[abc]\n4abc5abc6"), 15)
-
- def test_newlines_mixed_with_commas(self):
- self.assertEqual(self.calc.add("1,2\n3"), 6)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("5"), 5)
-
- def test_custom_delimiters_varied(self):
- self.assertEqual(self.calc.add("//_\n7_8_9"), 24)
-
- def test_multiple_negatives(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-1,-2")
- self.assertIn("negatives not allowed", str(context.exception))
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_me_on_student6.py b/test_me_on_student6.py
deleted file mode 100644
index 9e6e723d8ea4d41e3a53021dca420bcb998d3c78..0000000000000000000000000000000000000000
--- a/test_me_on_student6.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import unittest
-from other.student6.Calculator_combined import StringCalculator #lasse
-
-class TestStudent6OnMe(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_add_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_add_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_add_two_numbers(self):
- self.assertEqual(self.calc.add("10,20"), 30)
-
- def test_add_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3"), 6)
- self.assertEqual(self.calc.add("10,20,30,40"), 100)
-
- def test_add_with_newline_separator(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
- self.assertEqual(self.calc.add("10\n20\n30"), 60)
-
- def test_add_single_negative_number(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("1,-2,3")
- self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-2]")
-
- def test_add_multiple_negative_numbers(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-10\n-20,-30")
- self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-10, -20, -30]")
-
- def test_add_with_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
- self.assertEqual(self.calc.add("//x\n7x8\n9"), 24)
-
- def test_invalid_custom_delimiter_format(self):
- with self.assertRaises(ValueError):
- self.calc.add("//;1;2")
-
- def test_ignore_numbers_greater_than_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
- self.assertEqual(self.calc.add("1002,50200"), 0)
-
- def test_add_with_custom_delimiter_multiple_characters(self):
- self.assertEqual(self.calc.add("//[**]\n1**2**3"), 6)
- self.assertEqual(self.calc.add("//[###]\n10###20###30"), 60)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_me_on_student7.py b/test_me_on_student7.py
deleted file mode 100644
index e320a61e3803569bb828e52543768198601c0b6e..0000000000000000000000000000000000000000
--- a/test_me_on_student7.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import unittest
-from other.student7.Calculator import StringCalculator # Student 7s Code wird getestet
-
-class TestMeOnStudent7(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_custom_delimiter(self):
- self.assertEqual(self.calc.add("//|\n1|2|3|4"), 10)
-
- def test_newlines_and_large_numbers(self):
- self.assertEqual(self.calc.add("1\n2,1001"), 3)
-
- def test_negative_handling(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("1,-2,-3")
- self.assertEqual(str(context.exception), "Negatives not allowed: -2, -3")
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student1_on_me.py b/test_student1_on_me.py
deleted file mode 100644
index 41a50daafe34fd9db4b7f41261e2dc7db5706bbc..0000000000000000000000000000000000000000
--- a/test_student1_on_me.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator
-
-class TestStudent1OnMyCalc(unittest.TestCase):
- def setUp(self):
- self.c = StringCalculator()
-
- def test_empty(self):
- self.assertEqual(self.c.add(""), 0)
-
- def test_oneNumber(self):
- self.assertEqual(self.c.add("1"), 1)
-
- def test_addingTwoNumbers(self):
- self.assertEqual(self.c.add("1,2"), 3)
-
- def test_addingTwoNumbersWithZero(self):
- self.assertEqual(self.c.add("0,5"), 5)
-
- def test_handleFloat(self):
- with self.assertRaises(Exception):
- self.c.add("3.5")
-
- def test_handleLetter(self):
- with self.assertRaises(Exception):
- self.c.add("1, z")
-
- def test_addWithBackslashN(self):
- self.assertEqual(self.c.add("1\n2,3"), 6)
-
- def test_negativeValues(self):
- with self.assertRaises(ValueError):
- self.c.add("-3")
-
- def test_delimiter(self):
- self.assertEqual(self.c.add("//;\n1;2"), 3)
-
- def test_thousandone(self):
- self.assertEqual(self.c.add("2, 1001"), 2)
-
- def test_multidelimiter(self):
- self.assertEqual(self.c.add("//[***]\n1***2***3"), 6)
-
- def test_multi_negative(self):
- with self.assertRaises(ValueError):
- self.c.add("-3, -4")
-
- def test_space_between_numbers(self):
- self.assertEqual(self.c.add(" 4 , 5"), 9)
-
- def test_multiple_num_with_thousandone(self):
- self.assertEqual(self.c.add(" 2, 1001, 5"), 7)
-
- def test_empty_text(self):
- self.assertEqual(self.c.add("//;\n"), 0)
-
- def test_one_number_with_empty_string(self):
- self.assertEqual(self.c.add("1,"), 1)
-
- def test_negative_with_positive(self):
- with self.assertRaises(ValueError):
- self.c.add("-2, 5")
-
- def test_mixture(self):
- with self.assertRaises(ValueError):
- self.c.add("//;\n-1;2;1001;-3")
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student2_on_me.py b/test_student2_on_me.py
deleted file mode 100644
index ad6d014541c3df51cde650a07974c6b5386646a8..0000000000000000000000000000000000000000
--- a/test_student2_on_me.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator # Wasili
-
-class TestStudent2OnMe(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_add_empty(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_add_one_string(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_add_two_string(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_add_multiple_string(self):
- self.assertEqual(self.calc.add("1,2,3,4,5,6,7"), 28)
-
- def test_add_new_lines(self):
- self.assertEqual(self.calc.add("1\n2,3,4"), 10)
-
- def test_add_exception(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-5")
- self.assertEqual(str(context.exception), "Negatives not allowed: -5")
-
- def test_add_negative_numbers(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-5,-2,-2")
- self.assertEqual(str(context.exception), "Negatives not allowed: -5, -2, -2")
-
- def test_add_different_delimiters(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
-
- def test_add_numbers_greater_than_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
- self.assertEqual(self.calc.add("2,10022\n6"), 8)
-
- def test_delimiters_of_any_length(self):
- self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
-
- def test_delimiters_of_any_length2(self):
- self.assertEqual(self.calc.add("//[*+*+*]\n1*+*+*2*+*+*3*+*+*220"), 226)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student3_on_me.py b/test_student3_on_me.py
deleted file mode 100644
index a498fc07f928bc4c93471fba72492027479390ee..0000000000000000000000000000000000000000
--- a/test_student3_on_me.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator #Momo
-
-class TestStudent3CasesOnMe(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("5"), 5)
-
- def test_multiple_numbers(self):
- self.assertEqual(self.calc.add("5,5"), 10)
-
- def test_unknown_amount_of_numbers(self):
- self.assertEqual(self.calc.add("1,2,3"), 6)
- self.assertEqual(self.calc.add("10,20,30,40"), 100)
- self.assertEqual(self.calc.add("1,2,3,4,5,6"), 21)
-
- def test_numbers_separated_by_newline(self):
- self.assertEqual(self.calc.add("1\n2"), 3)
- self.assertEqual(self.calc.add("1\n2\n3"), 6)
- self.assertEqual(self.calc.add("10,20\n30"), 60)
-
- def test_negative_number_exception(self):
- with self.assertRaises(ValueError) as e:
- self.calc.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.calc.add("-1,-2,3")
- self.assertEqual(str(e.exception), "Negatives not allowed: -1, -2")
-
- def test_add_numbers_with_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2;3"), 6)
-
- def test_ignore_numbers_over_1000(self):
- self.assertEqual(self.calc.add("1,1001,2,3"), 6)
-
- def test_custom_delimiter_with_long_pattern(self):
- self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
- self.assertEqual(self.calc.add("//[+++]\n1+++2+++3"), 6)
- self.assertEqual(self.calc.add("//[aa]\n1aa2aa3"), 6)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student4_on_me.py b/test_student4_on_me.py
deleted file mode 100644
index 70cde1ecfb2ff0ffd124b19898249cd1413ed37a..0000000000000000000000000000000000000000
--- a/test_student4_on_me.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator
-
-class TestStudent4CasesOnMe(unittest.TestCase):
- def setUp(self):
- self.calculator = StringCalculator()
-
- def test_empty_string_returns_zero(self):
- self.assertEqual(self.calculator.add(""), 0)
-
- def test_single_number_returns_value(self):
- self.assertEqual(self.calculator.add("1"), 1)
-
- def test_two_numbers_return_sum(self):
- self.assertEqual(self.calculator.add("1,2"), 3)
-
- def test_add_multiple_numbers(self):
- self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)
-
- def test_add_numbers_with_newlines(self):
- self.assertEqual(self.calculator.add("1\n2\n3"), 6)
-
- def test_add_negative_numbers(self):
- with self.assertRaises(ValueError) as e:
- self.calculator.add("-1,2,-3")
- 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)
-
- def test_add_numbers_with_custom_delimiter_different_symbol(self):
- self.assertEqual(self.calculator.add("//#\n4#5#6"), 15)
-
- def test_custom_delimiter_with_multiple_numbers(self):
- self.assertEqual(self.calculator.add("//:\n1:2:3:4:5:6"), 21)
-
- def test_add_numbers_greater_than_1000(self):
- self.assertEqual(self.calculator.add("1,1001,2,3"), 6)
-
- def test_add_numbers_with_newlines_and_ignore_above_1000(self):
- self.assertEqual(self.calculator.add("1\n2\n1000\n1001"), 1003)
-
- def test_add_numbers_with_custom_delimiter_long_length(self):
- self.assertEqual(self.calculator.add("//[***]\n1***2***3"), 6)
-
- def test_custom_long_delimiter_with_large_number_ignored(self):
- self.assertEqual(self.calculator.add("//[***]\n1***1001***2"), 3)
-
- def test_custom_long_delimiter_with_negative_numbers(self):
- with self.assertRaises(ValueError) as e:
- self.calculator.add("//[***]\n1***-2***3***-4")
- self.assertEqual(str(e.exception), "Negatives not allowed: -2, -4")
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student5_on_me.py b/test_student5_on_me.py
deleted file mode 100644
index f61272306c7f41d22d0595d33d523e9c26c583a0..0000000000000000000000000000000000000000
--- a/test_student5_on_me.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator
-
-class TestStudent5OnMyCode(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_add_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_add_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_add_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_add_multiple_numbers(self):
- 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):
- 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):
- 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):
- with self.assertRaises(ValueError) as context:
- self.calc.add("1,-2")
- self.assertIn("Negatives not allowed", str(context.exception))
-
- def test_add_raises_exception_on_multiple_negatives(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-1,-2,3")
- self.assertIn("Negatives not allowed", str(context.exception))
-
- def test_add_with_custom_delimiter(self):
- 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):
- 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):
- 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()
diff --git a/test_student6_on_me.py b/test_student6_on_me.py
deleted file mode 100644
index f21ca8bd646ba99ee04df6e5ed6621b34820975c..0000000000000000000000000000000000000000
--- a/test_student6_on_me.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator # lasse
-
-class TestStudent6OnMe(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_add_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_add_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_add_two_numbers(self):
- self.assertEqual(self.calc.add("10,20"), 30)
-
- def test_add_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3"), 6)
- self.assertEqual(self.calc.add("10,20,30,40"), 100)
-
- def test_add_with_newline_separator(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
- self.assertEqual(self.calc.add("10\n20\n30"), 60)
-
- def test_add_single_negative_number(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("1,-2,3")
- self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-2]")
-
- def test_add_multiple_negative_numbers(self):
- with self.assertRaises(ValueError) as context:
- self.calc.add("-10\n-20,-30")
- self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-10, -20, -30]")
-
- def test_add_with_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
- self.assertEqual(self.calc.add("//x\n7x8\n9"), 24)
-
- def test_invalid_custom_delimiter_format(self):
- with self.assertRaises(ValueError):
- self.calc.add("//;1;2")
-
- def test_ignore_numbers_greater_than_1000(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
- self.assertEqual(self.calc.add("1002,50200"), 0)
-
- def test_add_with_custom_delimiter_multiple_characters(self):
- self.assertEqual(self.calc.add("//[**]\n1**2**3"), 6)
- self.assertEqual(self.calc.add("//[###]\n10###20###30"), 60)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_student7_on_me.py b/test_student7_on_me.py
deleted file mode 100644
index 626f26385d917dc7b4b1cb222069047d4a9ee20f..0000000000000000000000000000000000000000
--- a/test_student7_on_me.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import unittest
-from my_string_calculator import StringCalculator # Hatice und ich hatten den selben code
-
-class TestStudent7OnMe(unittest.TestCase):
- def setUp(self):
- self.calc = StringCalculator()
-
- def test_empty_string(self):
- self.assertEqual(self.calc.add(""), 0)
-
- def test_single_number(self):
- self.assertEqual(self.calc.add("1"), 1)
-
- def test_two_numbers(self):
- self.assertEqual(self.calc.add("1,2"), 3)
-
- def test_multiple_numbers(self):
- self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
-
- def test_numbers_with_newline(self):
- self.assertEqual(self.calc.add("1\n2,3"), 6)
-
- def test_negative_number(self):
- with self.assertRaises(ValueError) as e:
- self.calc.add("1,-2")
- self.assertEqual(str(e.exception), "Negatives not allowed: -2")
-
- def test_custom_delimiter(self):
- self.assertEqual(self.calc.add("//;\n1;2"), 3)
-
- def test_large_numbers_ignored(self):
- self.assertEqual(self.calc.add("2,1001"), 2)
-
-if __name__ == "__main__":
- unittest.main()