diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..77b724c4358591816346c24827ee84261dcb97c3
Binary files /dev/null and b/.DS_Store differ
diff --git a/Feature1.py b/Feature1.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2a76ece9263d47a3629586f6def03e775763812
--- /dev/null
+++ b/Feature1.py
@@ -0,0 +1,32 @@
+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
new file mode 100644
index 0000000000000000000000000000000000000000..313c83859224784eac53ffb5958c3e0c872ee112
--- /dev/null
+++ b/Feature2.py
@@ -0,0 +1,41 @@
+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
new file mode 100644
index 0000000000000000000000000000000000000000..e97fdae58521764c186681c72bcc831a5c676654
--- /dev/null
+++ b/Feature3.py
@@ -0,0 +1,61 @@
+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
new file mode 100644
index 0000000000000000000000000000000000000000..0a5f7530f0f7134fc3f8806f54246d051172a010
--- /dev/null
+++ b/Feature4.py
@@ -0,0 +1,80 @@
+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
new file mode 100644
index 0000000000000000000000000000000000000000..4bb39d4e56abfa1a9bf0d19de26b6dd8a927de04
--- /dev/null
+++ b/Feature5.py
@@ -0,0 +1,88 @@
+from abc import ABC, abstractmethod
+import unittest
+
+class IStringCalculator(ABC):
+    @abstractmethod
+    def add(self, numbers: str) -> int:
+        pass
+
+class StringCalculator(IStringCalculator):
+    def add(self, numbers: str) -> int:
+        if not numbers:
+            return 0
+        
+        # Überprüfe, ob ein benutzerdefiniertes Trennzeichen angegeben ist
+        if numbers.startswith("//"):
+            delimiter_line_end = numbers.find("\n")
+            delimiter = numbers[2:delimiter_line_end]  # Extrahiere das Trennzeichen
+            numbers = numbers[delimiter_line_end + 1:]  # Entferne die erste Zeile mit dem Trennzeichen
+            
+        else:
+            delimiter = ','  # Standard-Trennzeichen ist Komma, 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
new file mode 100644
index 0000000000000000000000000000000000000000..0f35297ebc07e1bd3d13bb70713f3ecbe5b9f33a
--- /dev/null
+++ b/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/README.md b/README.md
index 13edffaf418f8691c11b26ec6365b78154b9b111..3898420c079045c33c1ab15bc63114ee31d17a43 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Assignment 2
+# Assignement_02
 
 
 
@@ -15,14 +15,14 @@ Already a pro? Just edit this README.md and make it your own. Want to make it ea
 
 ```
 cd existing_repo
-git remote add origin https://gitlab.reutlingen-university.de/Marvin.Serchimo/assignment-2.git
+git remote add origin https://gitlab.reutlingen-university.de/Alma.Berisha/assignement_02.git
 git branch -M main
 git push -uf origin main
 ```
 
 ## Integrate with your tools
 
-- [ ] [Set up project integrations](https://gitlab.reutlingen-university.de/Marvin.Serchimo/assignment-2/-/settings/integrations)
+- [ ] [Set up project integrations](https://gitlab.reutlingen-university.de/Alma.Berisha/assignement_02/-/settings/integrations)
 
 ## Collaborate with your team
 
diff --git a/feature7 b/feature7
index 92de9259e2cee84a471e28f08d93682e34514b38..8e5342acee798ad53f477b18016d53887d9de4c0 100644
--- a/feature7
+++ b/feature7
@@ -1,6 +1,6 @@
 import re 
 import unittest
-
+from other.GotsisWasilios.TDD_StringCalculator import TestStringCalculator as Wasili
 class StringCalculator:
     def add(self, numbers: str) -> int:
         # Feature 1: Leerer String ergibt 0
diff --git a/other/GotsisWasilios/TDD_StringCalculator.py b/other/GotsisWasilios/TDD_StringCalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab815fa39c47d98569acffd1e808502bcb285a94
--- /dev/null
+++ b/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/other/GotsisWasilios/__pycache__/TDD_StringCalculator.cpython-313.pyc b/other/GotsisWasilios/__pycache__/TDD_StringCalculator.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0560b12c2d952c1f11c1e0cbf8071d3f060cdc72
Binary files /dev/null and b/other/GotsisWasilios/__pycache__/TDD_StringCalculator.cpython-313.pyc differ
diff --git a/report.md b/report.md
new file mode 100644
index 0000000000000000000000000000000000000000..27cbe3e5f6852876a1aeca8c5e495819395465de
--- /dev/null
+++ b/report.md
@@ -0,0 +1,11 @@
+## Eigene Tests gegen andere Implementierungen
+
+| Name              | Interface break | Failed Testcases |
+|-------------------|------------------|-------------------|
+| AliciMuhamed      | –                | –                 |
+| BerishaAlma       | –                | –                 |
+| GotsisWasilios    | no               | 0                 |
+| PikkemaatLasse    | –                | –                 |
+| RafehDaniel       | –                | –                 |
+| WeishauptOrlando  | –                | –                 |
+| YildirimHatice    | –                | –                 |
diff --git a/stringCalculator.py b/stringCalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9a7682047dc083481c1547f9a9ef1d5bed8a72c
--- /dev/null
+++ b/stringCalculator.py
@@ -0,0 +1,29 @@
+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