diff --git a/others/Dani/DaniStringCalculator.py b/others/Dani/DaniStringCalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..150a50b2386f2f6a01e5fc53692d0165b3942069
--- /dev/null
+++ b/others/Dani/DaniStringCalculator.py
@@ -0,0 +1,164 @@
+# Bei einer leeren Eingabe "" soll die Zahl 0 ausgegeben werden.
+# Bei der Eingabe "1" soll die 1 ausgegeben werden.
+# Bei der Eingabe von 2 Zahlen als Strings separiert durch "," (z.B. "1, 2") soll die Zahl 3 ausgegeben werden
+# Bei der Eingabe "0, 5" soll die Zahl 5 ausgegeben werden.
+# Bei der Eingabe von Float-Werten z.B. 3.5 soll "only integers allowed" ausgegeben werden.
+# Bei der Eingabe von Buchstaben z.B. 1, z soll "only integers allowed" ausgegeben werden.
+# Bei der Eingabe von 2 Zahlen als Strings separiert durch "\n" (z.B. "1\n2,3") soll 6 ausgegeben werden
+# Bei der Eingabe von negativen Zahlen (z.B. -3) soll "negatives not allowed" ausgegeben werden
+# Bei der Eingabe von Zahlen mit einem benutzerdefinierten Trennzeichen soll die Summe der Zahlen berechnet werden (z.B. //;\n1;2 = 3)
+# Bei Eingabe von Zahlen >1000 sollen diese ignoriert werden (z.B. 2 + 1001 = 2)
+# Bei der Eingabe von Zahlen mit einem benutzerdefinierten Trennzeichen soll die Summe der Zahlen berechnet werden. Trennzeichen können unbegrenzt lang sein (z.B. “//[***]\n1***2***3†= 6).
+# Bei der Eingabe mehrerer negativen Zahlen (z.B. -3, -4) sollen die Zahlen in der exception ausgegeben werden
+# Bei der Eingabe von Zahlen mit Leerzeichen soll dennoch die Summe ausgegeben werden (z.B." 4 , 5" = 9)
+# Bei der Eingabe "2, 1001, 5" soll die Zahl 7 ausgegeben werden
+# Bei der Eingabe von Texten mit leeren Trennzeichen (z.B. "//;\n") soll die Zahl 0 ausgegeben werden
+# Bei der Eingabe von "1, " soll die Zahl 1 ausgegeben werden
+# Bei der Eingabe von "-2, 5" soll "negatives not allowed" ausgegeben werden
+# Bei der Eingabe von "//;\n-1;2;1001;-3" soll "negatives not allowed [-1, -3]" ausgegeben werden
+
+import unittest
+from abc import ABC, abstractmethod
+from src.stringcalculator import StringCalculator #Auskommentieren, falls andere Implementierung genutzt wird
+'''
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ pass
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+
+ if numbers == "":
+ return 0
+
+ delimiter = ";"
+
+ if numbers.startswith("//"):
+ sep = numbers.split("\n", 1)
+ delimiter_sep = sep[0][2:]
+
+ if delimiter_sep.startswith("[") and delimiter_sep.endswith("]"):
+ delimiter = delimiter_sep[1:-1]
+
+ else:
+ delimiter = delimiter_sep[0]
+
+ numbers = sep[1]
+
+ numbers = numbers.replace("\n", delimiter).replace(delimiter, ",")
+
+ list = numbers.split(",")
+ result = 0
+
+ negative_numbers = []
+
+ for num in list:
+ num = num.strip()
+ if num == "":
+ continue
+
+ if "." in num:
+ return "only integers allowed"
+
+ try:
+ number = int(num)
+ except ValueError:
+ return "only integers allowed"
+
+ 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()
+
+# python -m unittest others.Dani.DaniStringCalculator -v
\ No newline at end of file
diff --git a/others/Dani/reportDaniImp.md b/others/Dani/reportDaniImp.md
new file mode 100644
index 0000000000000000000000000000000000000000..07b2fdaf05fb9bcf9811a2ce85456179edef5d2f
--- /dev/null
+++ b/others/Dani/reportDaniImp.md
@@ -0,0 +1,5 @@
+| Name | Interface break | Failed Testcases | Comment |
+|------|-----------------|--------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|
+| Dani | no | test_add_multiple_negative_numbers (tests.testStringcalculator.TestStringCalculator) ... FAIL | |
+| Dani | no | test_add_single_negative_number (tests.testStringcalculator.TestStringCalculator) ... FAIL | |
+| Dani | no | test_invalid_custom_delimiter_format (tests.testStringcalculator.TestStringCalculator) ... ERROR | Implementierung für falsche Eingabe nicht vorhanden, es wird immer angenommen, dass es mit "" startet und mit \n endet. |
\ No newline at end of file
diff --git a/others/Dani/reportDaniTests.md b/others/Dani/reportDaniTests.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b7e4b14ecbf8a4ca4dcce2bd696b09dfeb6525e
--- /dev/null
+++ b/others/Dani/reportDaniTests.md
@@ -0,0 +1,10 @@
+| Name | Interface break | Failed Testcases | Comment |
+|------|-----------------|-----------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Dani | no | test_empty_text (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | Der Fehler tritt auf, weil die Eingabe //;\n im Code ist, was bedeutet, dass ein Benutzer nur einen Delimiter angibt, aber keine Zahlen folgen. |
+| Dani | no | test_handleFloat (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | Die Eingabe 3.5 wird als Gleitkommazahl interpretiert, aber dein Code erwartet eine ganze Zahl (int). |
+| Dani | no | test_handleLetter (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | Die Eingabe 1, z enthält einen Buchstaben (z), was zu einem Fehler führt, da der Code erwartet, dass nur Zahlen verarbeitet werden. |
+| Dani | no | test_mixture (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | In diesem Test ist die Eingabe -1;2;1001;-3, was negative Zahlen enthält. Dein Code löst eine Fehlermeldung aus, weil negative Zahlen nicht erlaubt sind. |
+| Dani | no | test_multi_negative (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | Hier wird eine ähnliche Situation wie in test_mixture festgestellt, nur mit zwei negativen Zahlen. |
+| Dani | no | test_negativeValues (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | |
+| Dani | no | test_negative_with_positive (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | |
+| Dani | no | test_one_number_with_empty_string (others.Dani.DaniStringCalculator.TestStringCalculator) ... ERROR | Die Eingabe 1, enthält einen Fehler, da das letzte Komma keine Zahl nach sich zieht und somit beim Parsen ein leerer String ('') auftritt. |
\ No newline at end of file
diff --git a/others/Orlando/OrlandoInterfaces.py b/others/Orlando/OrlandoInterfaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..be069d6d910a5d5c44d8c083ec4429cfaac516b6
--- /dev/null
+++ b/others/Orlando/OrlandoInterfaces.py
@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+# Definition des Interfaces für den StringCalculator
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ """
+ Addiert beliebig viele Zahlen, die durch Kommas getrennt sind.
+ Leere oder nur aus Leerzeichen bestehende Einträge werden ignoriert.
+
+ :param numbers: String mit Zahlen (z.B. "1,2,3")
+ :return: Summe der Zahlen als int
+ """
+ pass
+
+class ICounter(ABC):
+ @abstractmethod
+ def count_ed(self, s: str) -> int:
+ """Zählt die Buchstaben 'E' und 'D' in einem String (Case-Insensitive)."""
+ pass
+class IRomanConverter(ABC):
+ @abstractmethod
+ def roman_to_int(self, s: str) -> int:
+ """Konvertiert eine römische Zahl (String) in eine Dezimalzahl."""
+ pass
+
+class ICalculator(ABC):
+ @abstractmethod
+ def calculate(self, expression: str) -> float:
+ pass
\ No newline at end of file
diff --git a/others/Orlando/OrlandoStringCalculator.py b/others/Orlando/OrlandoStringCalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..66df70f9136942c2db8b6dc7c2ef23ded8ff350f
--- /dev/null
+++ b/others/Orlando/OrlandoStringCalculator.py
@@ -0,0 +1,61 @@
+# Implementierung von IStringCalculator
+
+from others.Orlando.OrlandoInterfaces import IStringCalculator
+
+
+class StringCalculator(IStringCalculator):
+ def add(self, numbers: str) -> int:
+ """
+ Addiert beliebig viele Zahlen, getrennt durch Kommas, Zeilenumbrüche
+ oder einen benutzerdefinierten Delimiter.
+ Leere oder whitespace-only Einträge werden ignoriert.
+
+ Beispiele:
+ - "" → 0
+ - "1" → 1
+ - "1,2" → 3
+ - "1,2,3,4,5" → 15
+ - "1,,2" → 3
+ - "1, ,2" → 3
+ - ",,1,,2,,," → 3
+
+ :param numbers: Zahlen als String, getrennt durch Komma
+ :return: Summe der gültigen Zahlen als int
+ """
+ if not numbers:
+ return 0
+
+ delimiter = ","
+
+
+ if numbers.startswith("//"):
+ header, numbers = numbers.split("\n", 1)
+
+ # Mehrzeichen-Delimiter: z. B. //[***]
+ if header.startswith("//[") and header.endswith("]"):
+ delimiter = header[3:-1] # Extrahiere z. B. "***"
+ else:
+ delimiter = header[2:] # Einzeichen-Delimiter
+
+ # Ersetze \n durch Komma (Standard)
+ numbers = numbers.replace("\n", ",")
+
+ # Delimiter ersetzen durch Komma (evtl. mehrere Zeichen)
+ numbers = numbers.replace(delimiter, ",")
+
+ number_list = numbers.split(",")
+
+ # Ignoriere leere oder whitespace-only Einträge
+ cleaned_numbers = [
+ int(n.strip()) for n in number_list if n.strip() != ""
+ ]
+
+ # Negativ-Prüfung
+ negatives = [n for n in cleaned_numbers if n < 0]
+ if negatives:
+ raise ValueError(f"negatives not allowed: {', '.join(map(str, negatives))}")
+
+ # Zahlen > 1000 ignorieren
+ cleaned_numbers = [n for n in cleaned_numbers if n <= 1000]
+
+ return sum(cleaned_numbers)
\ No newline at end of file
diff --git a/tests/testStringcalculator.py b/tests/testStringcalculator.py
index 718074c4fd68c2eed352909c674200bec6964548..75214d70193b2ecf8962e85e7313e6d2c55d2fcb 100644
--- a/tests/testStringcalculator.py
+++ b/tests/testStringcalculator.py
@@ -24,13 +24,18 @@
# Bei Eingabe von //[###]\n10###20###30 soll 60 ausgegeben werden
'''
+Eigener Code:
import unittest
from src.interfaces import IStringCalculator
from src.stringcalculator import StringCalculator
-'''
+
+Orlandos Code:
import unittest
from others.Orlando.OrlandoInterfaces import IStringCalculator
from others.Orlando.OrlandoStringCalculator import StringCalculator
+'''
+import unittest
+from others.Dani.DaniStringCalculator import IStringCalculator, StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
diff --git a/testsOthers/testsOrlando/OrlandoTestStringCalculator.py b/testsOthers/testsOrlando/OrlandoTestStringCalculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff7f29de93780a4ce7c1d96a3248424ea91dee4c
--- /dev/null
+++ b/testsOthers/testsOrlando/OrlandoTestStringCalculator.py
@@ -0,0 +1,115 @@
+# Testfälle add(numbers: str) -> int – StringCalculator
+
+# 1. Leerer String
+# Eingabe: "" → Erwartete Ausgabe: 0
+
+# 2. Einzelne Zahl
+# Eingabe: "1" → Erwartete Ausgabe: 1
+
+# 3. Zwei Zahlen, getrennt durch Komma
+# Eingabe: "1,2" → Erwartete Ausgabe: 3
+
+# 4. Mehr als zwei Zahlen (beliebig viele erlaubt)
+# Eingabe: "1,2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2,3,4,5" → Erwartete Ausgabe: 15
+
+# 5. Leere Einträge ignorieren
+# Eingabe: "1,,2" → Erwartete Ausgabe: 3
+# Eingabe: "1, ,2" → Erwartete Ausgabe: 3
+# Eingabe: ",,1,,2,,," → Erwartete Ausgabe: 3
+
+# 6. Zeilenumbrüche als Trennzeichen erlauben
+# Eingabe: "1\n2,3" → Erwartete Ausgabe: 6
+# Eingabe: "1,2\n3" → Erwartete Ausgabe: 6
+# Eingabe: "1\n2\n3" → Erwartete Ausgabe: 6
+
+# 8. Negative Zahlen → Exception mit allen negativen Werten
+# Eingabe: "1,-2" → Exception mit Message "negatives not allowed: -2"
+# Eingabe: "-1,-2,3" → Exception mit Message "negatives not allowed: -1, -2"
+
+# 9. Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+# Eingabe: "//;\n1;2" → 3
+# Eingabe: "//|\n4|5|6" → 15
+# Eingabe: "//_\n7_8_9" → 24
+
+# 10. Zahlen größer als 1000 ignorieren
+# Eingabe: "2,1001" → 2
+# Eingabe: "1000,1" → 1001 (1000 zählt noch mit)
+# Eingabe: "1234,1001,3" → 3
+
+# 11. Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+# Eingabe: "//[***]\n1***2***3" → 6
+# Eingabe: "//[abc]\n4abc5abc6" → 15
+# Eingabe: "//[+]\n1+2+3" → 6
+
+import unittest
+from src.stringcalculator import StringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ # Vor jedem Test wird eine Instanz des Calculators erstellt
+ self.calc = StringCalculator()
+
+ def test_add_empty_string(self):
+ # Leerer String → 0
+ self.assertEqual(self.calc.add(""), 0)
+
+ def test_add_single_number(self):
+ # Ein einzelner Wert → int
+ self.assertEqual(self.calc.add("1"), 1)
+
+ def test_add_two_numbers(self):
+ # Zwei Zahlen → Summe
+ self.assertEqual(self.calc.add("1,2"), 3)
+
+ def test_add_multiple_numbers(self):
+ # Mehr als zwei Zahlen → Summe
+ self.assertEqual(self.calc.add("1,2,3"), 6)
+ self.assertEqual(self.calc.add("1,2,3,4,5"), 15)
+
+ def test_add_ignores_empty_entries(self):
+ # Leere Einträge ignorieren → Summe
+ self.assertEqual(self.calc.add("1,,2"), 3)
+ self.assertEqual(self.calc.add("1, ,2"), 3)
+ self.assertEqual(self.calc.add(",,1,,2,,,"), 3)
+
+ def test_add_with_newlines_between_numbers(self):
+ # Zeilenumbrüche als Trennzeichen erlauben → Summe
+ self.assertEqual(self.calc.add("1\n2,3"), 6)
+ self.assertEqual(self.calc.add("1,2\n3"), 6)
+ self.assertEqual(self.calc.add("1\n2\n3"), 6)
+
+ def test_add_raises_exception_on_negative_number(self):
+ # Negative Zahlen → Exception mit allen negativen Werten
+ with self.assertRaises(ValueError) as context:
+ self.calc.add("1,-2")
+ self.assertIn("negatives not allowed: -2", str(context.exception))
+
+ def test_add_raises_exception_on_multiple_negatives(self):
+ # Negative Zahlen → Exception mit allen negativen Werten
+ with self.assertRaises(ValueError) as context:
+ self.calc.add("-1,-2,3")
+ self.assertIn("negatives not allowed: -1, -2", str(context.exception))
+
+ def test_add_with_custom_delimiter(self):
+ # Benutzerdefinierter Delimiter über Präfix: "//<delimiter>\n"
+ self.assertEqual(self.calc.add("//;\n1;2"), 3)
+ self.assertEqual(self.calc.add("//|\n4|5|6"), 15)
+ self.assertEqual(self.calc.add("//_\n7_8_9"), 24)
+
+ def test_add_ignores_numbers_greater_than_1000(self):
+ # Zahlen größer als 1000 ignorieren
+ self.assertEqual(self.calc.add("2,1001"), 2)
+ self.assertEqual(self.calc.add("1000,1"), 1001)
+ self.assertEqual(self.calc.add("1234,1001,3"), 3)
+
+ def test_add_with_multi_char_delimiter(self):
+ # Delimiter mit beliebiger Länge (Format: //[delimiter]\n)
+ self.assertEqual(self.calc.add("//[***]\n1***2***3"), 6)
+ self.assertEqual(self.calc.add("//[abc]\n4abc5abc6"), 15)
+ self.assertEqual(self.calc.add("//[+]\n1+2+3"), 6)
+
+if __name__ == "__main__":
+ unittest.main()
+
+# python -m unittest testsOthers.testsOrlando.OrlandoTestStringCalculator -v
\ No newline at end of file