featureBerishaAlma

feature7

 import re 
 import unittest
-from other.GotsisWasilios.TDD_StringCalculator import TestStringCalculator as Wasili
-class StringCalculator:
-    def add(self, numbers: str) -> int:
+from other.BerishaAlma.Feature6 import StringCalculator as Alma
+#class StringCalculator:
+ #   def add(self, numbers: str) -> int:
         # Feature 1: Leerer String ergibt 0
-        if not numbers:
-            return 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:]
+        #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)
+            #if delimiter_section.startswith("[") and delimiter_section.endswith("]"):
+             #   delimiter = re.escape(delimiter_section[1:-1])
+            #else:
+             #   delimiter = re.escape(delimiter_section)
 
-            delimiters.append(delimiter)
+            #delimiters.append(delimiter)
 
         # Feature 3: Erlaube Zeilenumbrüche als Trenner
-        split_pattern = "|".join(delimiters)
-        number_list = re.split(split_pattern, numbers)
+        #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)
+        #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))}")
+        #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)
+        #return sum(int(n) for n in number_list if n.strip() != "" and int(n) <= 1000)
 
 
 
@@ -53,7 +53,7 @@ class TestStringCalculator(unittest.TestCase):
 
     def setUp(self):
         """neue Instanz des StringCalculators vor jedem Test"""
-        self.calculator = StringCalculator()
+        self.calculator = Alma()
 
     def test_empty_string_returns_zero(self):
         """Feature 1: Leerer String soll 0 ergeben"""

other/BerishaAlma/Feature6.py

+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

other/BerishaAlma/stringCalculator.py

+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)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file

report.md

@@ -3,7 +3,7 @@
 | Name              | Interface break | Failed Testcases |
 |-------------------|------------------|-------------------|
 | AliciMuhamed      | –                | –                 |
-| BerishaAlma       | –                | –                 |
+| BerishaAlma       | no               | 4                 |
 | GotsisWasilios    | no               | 0                 |
 | PikkemaatLasse    | –                | –                 |
 | RafehDaniel       | –                | –                 |