From 42b2db8b2a8788e4fb81eedd169543edb0ddb827 Mon Sep 17 00:00:00 2001
From: Muhamed <Muhamedalici@hotmail.de>
Date: Tue, 1 Apr 2025 19:04:46 +0200
Subject: [PATCH] merging develop to main
---
muhamed_directory/String calculator | 124 +++++++++++++
muhamed_directory/other/Alma/Feature1.py | 32 ++++
muhamed_directory/other/Alma/Feature2.py | 41 +++++
muhamed_directory/other/Alma/Feature3.py | 61 +++++++
muhamed_directory/other/Alma/Feature4.py | 80 ++++++++
muhamed_directory/other/Alma/Feature5.py | 88 +++++++++
muhamed_directory/other/Alma/Feature6.py | 94 ++++++++++
.../Alma/__pycache__/Feature6.cpython-311.pyc | Bin 0 -> 8567 bytes
.../other/Alma/stringCalculator.py | 29 +++
.../other/Daniel/stringCalculator.py | 171 ++++++++++++++++++
.../other/Hatice/StringCalculator.py | 29 +++
muhamed_directory/other/Hatice/feature1.py | 32 ++++
muhamed_directory/other/Hatice/feature2.py | 40 ++++
muhamed_directory/other/Hatice/feature3.py | 57 ++++++
muhamed_directory/other/Hatice/feature4.py | 79 ++++++++
muhamed_directory/other/Hatice/feature5.py | 88 +++++++++
muhamed_directory/other/Hatice/feature6.py | 94 ++++++++++
muhamed_directory/other/Lasse/interfaces.py | 6 +
.../other/Lasse/stringcalculator.py | 36 ++++
.../other/Lasse/test_stringclaculator.py | 85 +++++++++
muhamed_directory/other/Marvin/feature7 | 127 +++++++++++++
.../other/Wasili/TDD_StringCalculator.py | 110 +++++++++++
.../other/Wasili/Testszenarien.txt | 13 ++
muhamed_directory/other/report.md | 3 +
test.txt => muhamed_directory/test.txt | 0
25 files changed, 1519 insertions(+)
create mode 100644 muhamed_directory/String calculator
create mode 100644 muhamed_directory/other/Alma/Feature1.py
create mode 100644 muhamed_directory/other/Alma/Feature2.py
create mode 100644 muhamed_directory/other/Alma/Feature3.py
create mode 100644 muhamed_directory/other/Alma/Feature4.py
create mode 100644 muhamed_directory/other/Alma/Feature5.py
create mode 100644 muhamed_directory/other/Alma/Feature6.py
create mode 100644 muhamed_directory/other/Alma/__pycache__/Feature6.cpython-311.pyc
create mode 100644 muhamed_directory/other/Alma/stringCalculator.py
create mode 100644 muhamed_directory/other/Daniel/stringCalculator.py
create mode 100644 muhamed_directory/other/Hatice/StringCalculator.py
create mode 100644 muhamed_directory/other/Hatice/feature1.py
create mode 100644 muhamed_directory/other/Hatice/feature2.py
create mode 100644 muhamed_directory/other/Hatice/feature3.py
create mode 100644 muhamed_directory/other/Hatice/feature4.py
create mode 100644 muhamed_directory/other/Hatice/feature5.py
create mode 100644 muhamed_directory/other/Hatice/feature6.py
create mode 100644 muhamed_directory/other/Lasse/interfaces.py
create mode 100644 muhamed_directory/other/Lasse/stringcalculator.py
create mode 100644 muhamed_directory/other/Lasse/test_stringclaculator.py
create mode 100644 muhamed_directory/other/Marvin/feature7
create mode 100644 muhamed_directory/other/Wasili/TDD_StringCalculator.py
create mode 100644 muhamed_directory/other/Wasili/Testszenarien.txt
create mode 100644 muhamed_directory/other/report.md
rename test.txt => muhamed_directory/test.txt (100%)
diff --git a/muhamed_directory/String calculator b/muhamed_directory/String calculator
new file mode 100644
index 0000000..212921e
--- /dev/null
+++ b/muhamed_directory/String calculator
@@ -0,0 +1,124 @@
+#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
+import unittest
+import re
+from abc import ABC, abstractmethod
+from other.Alma.Feature6 import StringCalculator as Alma
+
+class CalculatorInterface(ABC):
+ @abstractmethod
+ def add (self, numbers : str)-> int:
+ pass
+
+class StringCalculator(CalculatorInterface):
+ 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 = Alma()
+ 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()
diff --git a/muhamed_directory/other/Alma/Feature1.py b/muhamed_directory/other/Alma/Feature1.py
new file mode 100644
index 0000000..c2a76ec
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/Feature2.py b/muhamed_directory/other/Alma/Feature2.py
new file mode 100644
index 0000000..313c838
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/Feature3.py b/muhamed_directory/other/Alma/Feature3.py
new file mode 100644
index 0000000..e97fdae
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/Feature4.py b/muhamed_directory/other/Alma/Feature4.py
new file mode 100644
index 0000000..0a5f753
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/Feature5.py b/muhamed_directory/other/Alma/Feature5.py
new file mode 100644
index 0000000..4bb39d4
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/Feature6.py b/muhamed_directory/other/Alma/Feature6.py
new file mode 100644
index 0000000..0f35297
--- /dev/null
+++ b/muhamed_directory/other/Alma/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/muhamed_directory/other/Alma/__pycache__/Feature6.cpython-311.pyc b/muhamed_directory/other/Alma/__pycache__/Feature6.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7226d04836270c33324500c51b213642808f180f
GIT binary patch
literal 8567
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
literal 0
HcmV?d00001
diff --git a/muhamed_directory/other/Alma/stringCalculator.py b/muhamed_directory/other/Alma/stringCalculator.py
new file mode 100644
index 0000000..f9a7682
--- /dev/null
+++ b/muhamed_directory/other/Alma/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
diff --git a/muhamed_directory/other/Daniel/stringCalculator.py b/muhamed_directory/other/Daniel/stringCalculator.py
new file mode 100644
index 0000000..232cb01
--- /dev/null
+++ b/muhamed_directory/other/Daniel/stringCalculator.py
@@ -0,0 +1,171 @@
+# 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
+
+
+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/muhamed_directory/other/Hatice/StringCalculator.py b/muhamed_directory/other/Hatice/StringCalculator.py
new file mode 100644
index 0000000..f9a7682
--- /dev/null
+++ b/muhamed_directory/other/Hatice/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
diff --git a/muhamed_directory/other/Hatice/feature1.py b/muhamed_directory/other/Hatice/feature1.py
new file mode 100644
index 0000000..c2a76ec
--- /dev/null
+++ b/muhamed_directory/other/Hatice/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/muhamed_directory/other/Hatice/feature2.py b/muhamed_directory/other/Hatice/feature2.py
new file mode 100644
index 0000000..b7fdb6e
--- /dev/null
+++ b/muhamed_directory/other/Hatice/feature2.py
@@ -0,0 +1,40 @@
+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/muhamed_directory/other/Hatice/feature3.py b/muhamed_directory/other/Hatice/feature3.py
new file mode 100644
index 0000000..e96297c
--- /dev/null
+++ b/muhamed_directory/other/Hatice/feature3.py
@@ -0,0 +1,57 @@
+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")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/muhamed_directory/other/Hatice/feature4.py b/muhamed_directory/other/Hatice/feature4.py
new file mode 100644
index 0000000..7521a3d
--- /dev/null
+++ b/muhamed_directory/other/Hatice/feature4.py
@@ -0,0 +1,79 @@
+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/muhamed_directory/other/Hatice/feature5.py b/muhamed_directory/other/Hatice/feature5.py
new file mode 100644
index 0000000..4bb39d4
--- /dev/null
+++ b/muhamed_directory/other/Hatice/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/muhamed_directory/other/Hatice/feature6.py b/muhamed_directory/other/Hatice/feature6.py
new file mode 100644
index 0000000..949c324
--- /dev/null
+++ b/muhamed_directory/other/Hatice/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()
diff --git a/muhamed_directory/other/Lasse/interfaces.py b/muhamed_directory/other/Lasse/interfaces.py
new file mode 100644
index 0000000..53246cf
--- /dev/null
+++ b/muhamed_directory/other/Lasse/interfaces.py
@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class IStringCalculator(ABC):
+ @abstractmethod
+ def add(self, numbers: str) -> int:
+ pass
\ No newline at end of file
diff --git a/muhamed_directory/other/Lasse/stringcalculator.py b/muhamed_directory/other/Lasse/stringcalculator.py
new file mode 100644
index 0000000..fc7e89a
--- /dev/null
+++ b/muhamed_directory/other/Lasse/stringcalculator.py
@@ -0,0 +1,36 @@
+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
diff --git a/muhamed_directory/other/Lasse/test_stringclaculator.py b/muhamed_directory/other/Lasse/test_stringclaculator.py
new file mode 100644
index 0000000..e2e765b
--- /dev/null
+++ b/muhamed_directory/other/Lasse/test_stringclaculator.py
@@ -0,0 +1,85 @@
+# 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
diff --git a/muhamed_directory/other/Marvin/feature7 b/muhamed_directory/other/Marvin/feature7
new file mode 100644
index 0000000..92de925
--- /dev/null
+++ b/muhamed_directory/other/Marvin/feature7
@@ -0,0 +1,127 @@
+import re
+import unittest
+
+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/muhamed_directory/other/Wasili/TDD_StringCalculator.py b/muhamed_directory/other/Wasili/TDD_StringCalculator.py
new file mode 100644
index 0000000..ab815fa
--- /dev/null
+++ b/muhamed_directory/other/Wasili/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/muhamed_directory/other/Wasili/Testszenarien.txt b/muhamed_directory/other/Wasili/Testszenarien.txt
new file mode 100644
index 0000000..b7312e7
--- /dev/null
+++ b/muhamed_directory/other/Wasili/Testszenarien.txt
@@ -0,0 +1,13 @@
+Convert str to int (String Calculator):
+- 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
\ No newline at end of file
diff --git a/muhamed_directory/other/report.md b/muhamed_directory/other/report.md
new file mode 100644
index 0000000..4b60175
--- /dev/null
+++ b/muhamed_directory/other/report.md
@@ -0,0 +1,3 @@
+| Name | Interface break | Failed Testcases |
+|--------|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Alma | yes (2) | test_add_numbers_greater_1000_and_minus, test_multiple_negative_numbers_exception, test_negative_number_exception, test_add_numbers_with_custom_delimiter, test_custom_del, test_custom_del2, test_custom_delimiter |
\ No newline at end of file
diff --git a/test.txt b/muhamed_directory/test.txt
similarity index 100%
rename from test.txt
rename to muhamed_directory/test.txt
--
GitLab