Update calculator and report

Other/AliciMuhamed_2/String calculator

+#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

Other/AliciMuhamed_2/my_calculator.py

 #Implementierung von AliciMuhamed auf meinen Testfälle: StringCalculator
 import unittest
-
-from string calculator import StringCalculator
+from String Calculator import IStringCalculator
+from String Calculator import StringCalculator
 
 class TestStringCalculator(unittest.TestCase):
     def setUp(self):
         self.calculator = StringCalculator()
     
     def test_implements_interface(self):
-        self.assertIsInstance(self.calculator, StringCalculator)
+        self.assertIsInstance(self.calculator, IStringCalculator)
 
     def test_empty_string(self):
         self.assertEqual(self.calculator.add(""), 0)

Other/AliciMuhamed_2/your_calculator.py

@@ -3,14 +3,14 @@
 
 import unittest
 from stringCalculator import StringCalculator
-
+from stringCalculator import IStringCalculator
 
 class TestStingCalculator(unittest.TestCase):
     def setUp(self):
         self.calculator = StringCalculator()   
 
     def test_implements_interface(self):
-        self.assertIsInstance(self.calculator, StringCalculator)
+        self.assertIsInstance(self.calculator, IStringCalculator)
 
     def test_empty_string(self):
         self.assertEqual(self.calculator.add(""), 0) #leerer string + 0

Other/BerishaAlma_2/my_calculator.py

@@ -2,13 +2,14 @@
 import unittest
 
 from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
 
 class TestStringCalculator(unittest.TestCase):
     def setUp(self):
         self.calculator = StringCalculator()
     
     def test_implements_interface(self):
-        self.assertIsInstance(self.calculator, StringCalculator)
+        self.assertIsInstance(self.calculator, IStringCalculator)
 
     def test_empty_string(self):
         self.assertEqual(self.calculator.add(""), 0)

Other/BerishaAlma_2/your_calculator.py

+#Implementierung von BerishaAlma auf meinen Testfälle: StringCalculator
+import unittest
+
+from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+    def setUp(self):
+        self.calculator = StringCalculator()
+    
+    def test_implements_interface(self):
+        self.assertIsInstance(self.calculator, IStringCalculator)
+
+    def test_empty_string(self):
+        self.assertEqual(self.calculator.add(""), 0)
+    
+    def test_single_number(self):
+        self.assertEqual(self.calculator.add("1"), 1)
+    
+    def test_two_numbers(self):
+        self.assertEqual(self.calculator.add("1,2"), 3)
+    
+    def test_multiple_numbers(self):
+        self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)
+    
+    def test_numbers_with_newline(self):
+        self.assertEqual(self.calculator.add("1\n2,3"), 6)
+    
+    def test_numbers_with_multiple_newlines(self):
+        self.assertEqual(self.calculator.add("1\n2\n3\n4\n5"), 15)
+    
+    def test_negative_number(self):
+        with self.assertRaises(ValueError) as context:
+            self.calculator.add("1,-2,3")
+        self.assertEqual(str(context.exception), "Negatives not allowed: -2")
+    
+    def test_multiple_negative_numbers(self):
+        with self.assertRaises(ValueError) as context:
+            self.calculator.add("1,-2,-3,4")
+        self.assertEqual(str(context.exception), "Negatives not allowed: -2, -3")
+    
+    def test_custom_delimiter(self):
+        self.assertEqual(self.calculator.add("//;\n1;2"), 3)
+    
+    def test_custom_delimiter_with_newline(self):
+        self.assertEqual(self.calculator.add("//;\n1;2\n3"), 6)
+    
+    def test_custom_delimiter_with_multiple_numbers(self):
+        self.assertEqual(self.calculator.add("//|\n1|2|3|4"), 10)
+    
+    def test_numbers_greater_than_1000(self):
+        self.assertEqual(self.calculator.add("2,1001"), 2)
+    
+    def test_numbers_greater_than_1000_with_custom_delimiter(self):
+        self.assertEqual(self.calculator.add("//;\n2;1001"), 2)
+    
+
+if __name__ == "__main__":
+    unittest.main()

Other/GotsisWasili_2/my_calculator.py

 #Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
 import unittest
-
+from TDD_StringCalculator import IStringCalculator
 from TDD_StringCalculator import StringCalculator
 
 class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
         self.calculator = StringCalculator()
     
     def test_implements_interface(self):
-        self.assertIsInstance(self.calculator, StringCalculator)
+        self.assertIsInstance(self.calculator, IStringCalculator)
 
     def test_empty_string(self):
         self.assertEqual(self.calculator.add(""), 0)

Other/GotsisWasili_2/your_calculator.py

 import unittest
 from stringCalculator import StringCalculator
+from stringCalculator import IStringCalculator
 
 #mplementierung der Testklasse für StringCalculator
 class TestStringCalculator(unittest.TestCase):
 
     def test_implements_interface(self):
         c = StringCalculator()
-        self.assertIsInstance(self.c, StringCalculator)
+        self.assertIsInstance(self.c, IStringCalculator)
 
     def test_add_empty(self):
         c = StringCalculator()

Other/PikkemaatLasse_2/my_calculator.py

 #Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
 import unittest
-
+from src.interfaces import IStringCalculator
 from src.stringcalculator import StringCalculator
 
 class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
         self.calculator = StringCalculator()
     
     def test_implements_interface(self):
-        self.assertIsInstance(self.calculator, StringCalculator)
+        self.assertIsInstance(self.calculator, IStringCalculator)
 
     def test_empty_string(self):
         self.assertEqual(self.calculator.add(""), 0)

Other/PikkemaatLasse_2/src/interfaces.py

+from abc import ABC, abstractmethod
+
+class IStringCalculator(ABC):
+    @abstractmethod
+    def add(self, numbers: str) -> int:
+        pass
\ No newline at end of file

Other/PikkemaatLasse_2/src/stringcalculator.py

+from src.interfaces import IStringCalculator
+import re
+
+
+class StringCalculator(IStringCalculator):
+    def add(self, numbers: str) -> int:
+        if not numbers:
+            return 0
+
+        if numbers.startswith("//"):
+            if "\n" not in numbers:
+                raise ValueError("Ungültiges Format: Nicht vollständig")
+            delimiter_end_index = numbers.index("\n")
+            delimiter_part = numbers[2:delimiter_end_index]
+            if delimiter_part.startswith("[") and delimiter_part.endswith("]"):
+                delimiter = delimiter_part[1:-1]
+            else:
+                delimiter = delimiter_part
+            numbers = numbers[delimiter_end_index + 1:]
+            numbers = numbers.replace(delimiter, ",")
+
+        numbers = numbers.replace("\n", ",")
+
+        # Split the string by commas, convert each value to an integer, and sum them up
+        try:
+            numbers_list = list(map(int, numbers.split(",")))
+        except ValueError:
+            raise ValueError("Ungültiges Zahlenformat: Enthält nicht-numerische Werte")
+
+        negative_numbers = [num for num in numbers_list if num < 0]
+        if negative_numbers:
+            raise ValueError(f"Negative nicht erlaubt: {negative_numbers}")
+
+        numbers_list = [num for num in numbers_list if num <= 1000]
+
+        return sum(numbers_list)
\ No newline at end of file

Other/PikkemaatLasse_2/tests/test_stringclaculator.py

+# Basis
+# Bei Eingabe keiner Zahl soll eine 0 ausgegeben werden
+# Bei Eingabe einer 1 soll 1 ausgegeben werden
+# Bei Eingabe einer 3,4 soll 7 ausgegeben werden
+# Bei Eingabe einer 10,20 soll 30 ausgegeben werden
+#Feature1 Längere Zahlenfolge
+# Bei Eingabe einer 1,2,3 soll 6 ausgegeben werden
+# Bei Eingabe einer 10,20,30,40 soll 100 ausgegeben werden
+#Feature2 Neues Trennzeichen neben dem Komma
+# Bei Eingabe von 1\n2,3 soll 6 ausgegeben werden
+# Bei Eingabe von 10\n20\n30 soll 60 ausgegeben werden
+#Feature3 Negative Zahlen ausschließen
+# Bei Eingabe von 1, -2, 3 soll ein Error erscheinen "Negative nicht erlaubt: [-2]
+# Bei Eingabe von -10\n -20, -30 soll ein Error erscheinen "Negative nicht erlaubt: [-10,-20,30]
+#Feature4 Eigene Trennzeichen eingeben
+# Bei Eingabe eines neuen Trennzeichen ";" //;\n1;2 soll 3 ausgegeben werden
+# Bei Eingabe eines neuen Trennzeichen "x" //-\n7x8\n9 soll 24 ausgegeben werden
+# Bei Eingabe eines neuen Trennzeichens ";" ohne vollständigen Ausdrück //;1;2 soll Ungültiges Format: Nicht vollständig
+#Feature5 Zahlen größer 1000 nicht erkennen
+# Bei Eingabe von 2,1001 soll 2 ausgegeben werden
+# Bei Eingabe von 1002, 50200 soll 0 asugegeben werden
+#Feature6 Begrenzungszeichen beliebig lang
+# Bei Eingabe von //[**]\n1**2**3 soll 6 ausgegeben werden
+# Bei Eingabe von //[###]\n10###20###30 soll 60 ausgegeben werden
+
+
+import unittest
+from src.interfaces import IStringCalculator
+from src.stringcalculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+    def setUp(self):
+        self.calculator: IStringCalculator = StringCalculator()  # Zugriff über das Interface
+
+    def test_add_empty_string(self):
+        self.assertEqual(self.calculator.add(""), 0)
+
+    def test_add_single_number(self):
+        self.assertEqual(self.calculator.add("1"), 1)
+
+    def test_add_two_numbers(self):
+        self.assertEqual(self.calculator.add("10,20"), 30)
+
+    def test_add_multiple_numbers(self):
+        self.assertEqual(self.calculator.add("1,2,3"), 6)
+        self.assertEqual(self.calculator.add("10,20,30,40"), 100)
+
+    def test_add_with_newline_separator(self):
+        self.assertEqual(self.calculator.add("1\n2,3"), 6)
+        self.assertEqual(self.calculator.add("10\n20\n30"), 60)
+
+    def test_add_single_negative_number(self):
+        with self.assertRaises(ValueError) as context:
+            self.calculator.add("1,-2,3")
+        print(str(context.exception))
+        self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-2]")
+
+    def test_add_multiple_negative_numbers(self):
+        with self.assertRaises(ValueError) as context:
+            self.calculator.add("-10\n-20,-30")
+        print(str(context.exception))
+        self.assertEqual(str(context.exception), "Negative nicht erlaubt: [-10, -20, -30]")
+
+    def test_add_with_custom_delimiter(self):
+        self.assertEqual(self.calculator.add("//;\n1;2"), 3)
+        self.assertEqual(self.calculator.add("//x\n7x8\n9"), 24)
+
+    def test_invalid_custom_delimiter_format(self):
+        with self.assertRaises(ValueError) as context:
+            self.calculator.add("//;1;2")
+        print(str(context.exception))
+
+    def test_ignore_numbers_greater_than_1000(self):
+        self.assertEqual(self.calculator.add("2,1001"), 2)
+        self.assertEqual(self.calculator.add("1002,50200"), 0)
+
+    def test_add_with_custom_delimiter_multiple_characters(self):
+        self.assertEqual(self.calculator.add("//[**]\n1**2**3"), 6)
+        self.assertEqual(self.calculator.add("//[###]\n10###20###30"), 60)
+
+if __name__ == "__main__":
+    unittest.main()
+
+# python -m unittest tests.test_stringcalculator
+# python -m unittest discover -s tests -v
\ No newline at end of file