From 04ae8f9a9a10fe7f3455ee7aee26675a1a2bdb80 Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sun, 6 Apr 2025 10:22:30 +0200
Subject: [PATCH 1/2] Aktualisiere report.md
---
Other/report.md | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/Other/report.md b/Other/report.md
index af401cb..6614ca3 100644
--- a/Other/report.md
+++ b/Other/report.md
@@ -22,3 +22,26 @@ Testfälle anderer Studierender auf meine Implementierung: RomanNumberConverter
|SerchimoMarvin | NaN | - |
|WeishauptOrlando | No | 4x AttributeError: 'RomanNumber' object has no attribute 'roman_to_int' |
+Meine Testfälle auf Implementierungen anderer Studierender: StringCalculator
+
+| Name | Interface break | Failed Testcases |
+|------------------|------------------|--------------------------------------------------|
+|AliciMuhamed | No | |
+|BerishaAlma | No | |
+|GotsisWasili | No | |
+|PikkemaatLasse | No | |
+|RafehDaniel | No | |
+|SerchimoMarvin | No | |
+|WeishauptOrlando | No | |
+
+Testfälle anderer Studierender auf meine Implementierung: StringCalculator
+
+| Name | Interface break | Failed Testcases |
+|------------------|------------------|--------------------------------------------------|
+|AliciMuhamed | No | |
+|BerishaAlma | No | |
+|GotsisWasili | No | |
+|PikkemaatLasse | No | |
+|RafehDaniel | No | |
+|SerchimoMarvin | No | |
+|WeishauptOrlando | No | |
\ No newline at end of file
--
GitLab
From aaca5989cb61a1055d346724df1b6482765ebd41 Mon Sep 17 00:00:00 2001
From: Hatice Yildirim <Hatice.Yildirim@student.reutlingen-university.de>
Date: Sun, 6 Apr 2025 11:17:46 +0200
Subject: [PATCH 2/2] Update calculator and report
---
Other/AliciMuhamed_2/String calculator | 136 ++++++++++++++
.../stringCalculator.cpython-312.pyc | Bin 6649 -> 6649 bytes
Other/AliciMuhamed_2/my_calculator.py | 6 +-
Other/AliciMuhamed_2/your_calculator.py | 4 +-
.../stringCalculatorr.cpython-312.pyc | Bin 6649 -> 6651 bytes
Other/BerishaAlma_2/my_calculator.py | 3 +-
Other/BerishaAlma_2/your_calculator.py | 59 ++++++
.../TDD_StringCalculator.cpython-312.pyc | Bin 0 -> 6235 bytes
.../stringCalculator.cpython-312.pyc | Bin 0 -> 6649 bytes
Other/GotsisWasili_2/my_calculator.py | 4 +-
Other/GotsisWasili_2/your_calculator.py | 3 +-
.../stringCalculator.cpython-312.pyc | Bin 6651 -> 6651 bytes
Other/PikkemaatLasse_2/my_calculator.py | 4 +-
.../__pycache__/interfaces.cpython-312.pyc | Bin 660 -> 660 bytes
.../stringcalculator.cpython-312.pyc | Bin 1920 -> 1920 bytes
Other/PikkemaatLasse_2/src/interfaces.py | 6 +
.../PikkemaatLasse_2/src/stringcalculator.py | 36 ++++
.../tests/test_stringclaculator.py | 85 +++++++++
.../stringCalculatorDaniel.cpython-312.pyc | Bin 0 -> 8056 bytes
.../stringCalculatorr.cpython-312.pyc | Bin 0 -> 6649 bytes
Other/RafehDaniel_2/my_calculator.py | 6 +-
Other/RafehDaniel_2/stringCalculatorDaniel.py | 171 ++++++++++++++++++
Other/RafehDaniel_2/your_calculator.py | 5 +-
.../stringCalculator.cpython-312.pyc | Bin 6651 -> 6651 bytes
Other/SerchimoMarvin_2/feature7 | 127 +++++++++++++
Other/SerchimoMarvin_2/your_calculator.py | 5 +-
.../stringCalculator.cpython-312.pyc | Bin 6653 -> 6653 bytes
Other/WeishauptOrlando_2/my_calculator.py | 4 +-
.../__pycache__/interfaces.cpython-312.pyc | Bin 2147 -> 2147 bytes
.../string_calculator.cpython-312.pyc | Bin 2410 -> 2410 bytes
Other/WeishauptOrlando_2/src/calculator.py | 44 +++++
Other/WeishauptOrlando_2/src/interfaces.py | 30 +++
.../src/string_calculator.py | 61 +++++++
.../WeishauptOrlando_2/tests/TestCount_ED.py | 34 ++++
Other/WeishauptOrlando_2/tests/__init__.py | 0
.../tests/test_calculator.py | 103 +++++++++++
Other/WeishauptOrlando_2/tests/test_roman.py | 66 +++++++
.../tests/test_string_calculator.py | 113 ++++++++++++
Other/report.md | 32 ++--
39 files changed, 1111 insertions(+), 36 deletions(-)
create mode 100644 Other/AliciMuhamed_2/String calculator
create mode 100644 Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc
create mode 100644 Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc
create mode 100644 Other/PikkemaatLasse_2/src/interfaces.py
create mode 100644 Other/PikkemaatLasse_2/src/stringcalculator.py
create mode 100644 Other/PikkemaatLasse_2/tests/test_stringclaculator.py
create mode 100644 Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc
create mode 100644 Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc
create mode 100644 Other/RafehDaniel_2/stringCalculatorDaniel.py
create mode 100644 Other/SerchimoMarvin_2/feature7
create mode 100644 Other/WeishauptOrlando_2/src/calculator.py
create mode 100644 Other/WeishauptOrlando_2/src/interfaces.py
create mode 100644 Other/WeishauptOrlando_2/src/string_calculator.py
create mode 100644 Other/WeishauptOrlando_2/tests/TestCount_ED.py
create mode 100644 Other/WeishauptOrlando_2/tests/__init__.py
create mode 100644 Other/WeishauptOrlando_2/tests/test_calculator.py
create mode 100644 Other/WeishauptOrlando_2/tests/test_roman.py
create mode 100644 Other/WeishauptOrlando_2/tests/test_string_calculator.py
diff --git a/Other/AliciMuhamed_2/String calculator b/Other/AliciMuhamed_2/String calculator
new file mode 100644
index 0000000..fc44a5a
--- /dev/null
+++ b/Other/AliciMuhamed_2/String calculator
@@ -0,0 +1,136 @@
+#vorher im anderen projekt jetzt im neuen projekt
+#test no string
+#test add 1 string
+#test adding 2 strings
+
+#add 3 strings
+#add 4 strings
+#add 6 strings
+
+#\n statt , bei 2 strings
+#\n statt , bei mehreren strings
+
+# eine negative zahl
+# mehrere negative zahlen
+
+# Delimiters:
+# add numbers seperated by a custom delimiter
+# Test with - Numbers
+
+#numbers over 1000 should be ignored
+#1001 + 2 should return 2
+#1001 -2 should return negatives not allowed
+
+#custom delimiters
+#input "//[***]\n1***2***3"
+#output 6
+
+import unittest
+import re
+
+class StringCalculator:
+ def __init__(self):
+ self.called_count = 0
+ def add (self, numbers : str)-> int: #Erwartet Integer
+ if not numbers:
+ return 0
+
+ if numbers.startswith("//"):
+ delimiter_end_index = numbers.index("\n")
+ delimiter_section = numbers[2:delimiter_end_index]
+ numbers = numbers[delimiter_end_index +1:]
+
+ if delimiter_section.startswith("[")and delimiter_section.endswith("]"):
+ delimiters = re.findall(r'\[([^\]]+)\]',delimiter_section)
+ else:
+ delimiters= [delimiter_section]
+
+ for delimiters in delimiters:
+ numbers = numbers.replace(delimiters,",")
+
+ numbers = numbers.replace("\n",",")
+
+ number_list = numbers.split(',')#aufteilung der strings
+ negative = [] #array für die negativen nummern
+ numbers_to_add = []
+ #total_sum = 0
+ for number_str in number_list: #jedes element in der liste wird durch genommen
+ #if number_str:
+ number = int(number_str)# summierung der integer
+ if number <0:
+ negative.append(number)
+ elif number > 1000:
+ continue
+ else:
+ numbers_to_add.append(number)
+ #total_sum += number
+
+ if negative:
+ print(f"Negative Zahlen:{negative} ")#ausgabe negative zahlen
+ raise ValueError(f"negatives not allowed: {','.join(map(str, negative))}")
+ self.called_count += 1
+ return sum(numbers_to_add)
+ def get_called_count(self):
+ return self.called_count
+
+
+class TestStingCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+ def test_empty_string(self):
+ self.assertEqual(self.calculator.add(""), 0) #leerer string + 0
+ def test_single_number(self):
+ self.assertEqual(self.calculator.add("5"),5) #eingabe von einem String
+ def test_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("5,5"),10)#eingabe mehrere strings
+ def test_unknowen_amount_of_numbers(self):
+ self.assertEqual(self.calculator.add("1,2,3"),6)
+ self.assertEqual(self.calculator.add("10,20,30,40"),100)
+ self.assertEqual(self.calculator.add("1,2,3,4,5,6"),21)
+ def test_numbers_seperated_by_newline(self):
+ self.assertEqual(self.calculator.add("1\n2"),3)
+ self.assertEqual(self.calculator.add("1\n2\n3"),6)
+ self.assertEqual(self.calculator.add("10,20\n30"),60)
+
+ def test_negative_number_exception(self):
+
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1,2")
+ self.assertEqual(str(e.exception), "negatives not allowed: -1")
+ def test_multiple_negative_numbers_exception(self):
+ with self.assertRaises(ValueError)as e:
+ self.calculator.add("-1,-2,3")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-2")
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1,-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")
+
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("-1\n-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -1,-3")
+ def test_add_numbers_with_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n1;2;3"),6)
+ self.assertEqual(self.calculator.add("//;\n1,2,3"),6)
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("//;\n-3,4")
+ self.assertEqual(str(e.exception),"negatives not allowed: -3")
+
+ def test_add_numbers_greater_than_1000(self):
+ self.assertEqual(self.calculator.add("1,1001,2,3"),6)
+ def test_add_numbers_greater_than_1000_1002(self):
+ self.assertEqual(self.calculator.add("1002,1,2,3"),6)
+ def test_add_numbers_greater_1000_and_minus(self):
+ with self.assertRaises(ValueError) as e:
+ self.calculator.add("//;\n-3,4;1001")
+ self.assertEqual(str(e.exception),"negatives not allowed: -3")
+ def test_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//[***]\n1***2***3"),6)
+ def test_custom_del(self):
+ self.assertEqual(self.calculator.add("//[+++]\n1+++2+++3"),6)
+ def test_custom_del2(self):
+ self.assertEqual(self.calculator.add("//[aa]\n1aa2aa3"),6)
+
+
+
+if __name__=='__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/AliciMuhamed_2/__pycache__/stringCalculator.cpython-312.pyc
index 268009bebff13d3c53c3ef6e1f80c2ba5edc84c2..a8cf6e6c5489f1becc13f385c49656466534422b 100644
GIT binary patch
delta 22
ccmexq{L`5CG%qg~0}yyU`j|d_BkvnY09)n=GXMYp
delta 22
ccmexq{L`5CG%qg~0}w>=e@uVBk@t-x09TC%#{d8T
diff --git a/Other/AliciMuhamed_2/my_calculator.py b/Other/AliciMuhamed_2/my_calculator.py
index 0d6c003..fda1866 100644
--- a/Other/AliciMuhamed_2/my_calculator.py
+++ b/Other/AliciMuhamed_2/my_calculator.py
@@ -1,14 +1,14 @@
#Implementierung von AliciMuhamed auf meinen Testfälle: StringCalculator
import unittest
-
-from string calculator import StringCalculator
+from String Calculator import IStringCalculator
+from String Calculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/AliciMuhamed_2/your_calculator.py b/Other/AliciMuhamed_2/your_calculator.py
index 0c826a8..ee41498 100644
--- a/Other/AliciMuhamed_2/your_calculator.py
+++ b/Other/AliciMuhamed_2/your_calculator.py
@@ -3,14 +3,14 @@
import unittest
from stringCalculator import StringCalculator
-
+from stringCalculator import IStringCalculator
class TestStingCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0) #leerer string + 0
diff --git a/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc b/Other/BerishaAlma_2/__pycache__/stringCalculatorr.cpython-312.pyc
index 5047f7559a0813d308e85fae57458ace61d9a67f..f1e5ec1d5ce5eb500a42111a816b63d1373577c9 100644
GIT binary patch
delta 197
zcmexq{M(rKG%qg~0}yyU`j~!wBQG}-Bl~1YrZh&j%?(Vh%#1vnkFmNlGIDR`V|QX?
z)S4W~@taY1vM=X<MuW+|Tz?sjfoz4z+1zg#&A_Zmo{y}SK;u474&;>C+|A3$$Y=wS
z*u0f*J0qk0=3IgAjEpXma|L8JHwq~;GJ1j~j|#IhGWu*jD`L&a=npnWQ|u38&}KDp
lZAQk>$w3lzjGB`#N}S;f1seT<nURt4I~xO|%H)-j0Ra3(I0XOz
delta 195
zcmexu{L`5CG%qg~0}w>=e@uVBk(Zl^k#({pQyL@7<_0ELW=5{f$5`DN896ueu{$v`
zYD^B~_|2$2*_ZP_quyj+uD^_iK(@l<Z0@&=CSX=2&qr2spmCok2Xe}6?&jrWWV8ZF
zY~ISZosrRYbFRR5Mn<Q}xdJkq8-<h^8QsB>M}^rL8ND{26|rVy^aY!vDfWjkV6&RI
jHX~#3<RFPUM)k=TCC=~!1C9Q`%*e=ipFw%@YRLcq1_3t_
diff --git a/Other/BerishaAlma_2/my_calculator.py b/Other/BerishaAlma_2/my_calculator.py
index 8ac359b..1504f02 100644
--- a/Other/BerishaAlma_2/my_calculator.py
+++ b/Other/BerishaAlma_2/my_calculator.py
@@ -2,13 +2,14 @@
import unittest
from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/BerishaAlma_2/your_calculator.py b/Other/BerishaAlma_2/your_calculator.py
index e69de29..1504f02 100644
--- a/Other/BerishaAlma_2/your_calculator.py
+++ b/Other/BerishaAlma_2/your_calculator.py
@@ -0,0 +1,59 @@
+#Implementierung von BerishaAlma auf meinen Testfälle: StringCalculator
+import unittest
+
+from stringCalculatorr import StringCalculator
+from stringCalculatorr import IStringCalculator
+
+class TestStringCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calculator = StringCalculator()
+
+ def test_implements_interface(self):
+ self.assertIsInstance(self.calculator, IStringCalculator)
+
+ def test_empty_string(self):
+ self.assertEqual(self.calculator.add(""), 0)
+
+ def test_single_number(self):
+ self.assertEqual(self.calculator.add("1"), 1)
+
+ def test_two_numbers(self):
+ self.assertEqual(self.calculator.add("1,2"), 3)
+
+ def test_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)
+
+ def test_numbers_with_newline(self):
+ self.assertEqual(self.calculator.add("1\n2,3"), 6)
+
+ def test_numbers_with_multiple_newlines(self):
+ self.assertEqual(self.calculator.add("1\n2\n3\n4\n5"), 15)
+
+ def test_negative_number(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("1,-2,3")
+ self.assertEqual(str(context.exception), "Negatives not allowed: -2")
+
+ def test_multiple_negative_numbers(self):
+ with self.assertRaises(ValueError) as context:
+ self.calculator.add("1,-2,-3,4")
+ self.assertEqual(str(context.exception), "Negatives not allowed: -2, -3")
+
+ def test_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n1;2"), 3)
+
+ def test_custom_delimiter_with_newline(self):
+ self.assertEqual(self.calculator.add("//;\n1;2\n3"), 6)
+
+ def test_custom_delimiter_with_multiple_numbers(self):
+ self.assertEqual(self.calculator.add("//|\n1|2|3|4"), 10)
+
+ def test_numbers_greater_than_1000(self):
+ self.assertEqual(self.calculator.add("2,1001"), 2)
+
+ def test_numbers_greater_than_1000_with_custom_delimiter(self):
+ self.assertEqual(self.calculator.add("//;\n2;1001"), 2)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc b/Other/GotsisWasili_2/__pycache__/TDD_StringCalculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac3ffe37efbe798d63fec133056f67d5dc7bd672
GIT binary patch
literal 6235
zcmd^DT~Hg>6~6l?t%PLEk8N-)kc}H7EFmNicI-3>2FLa!#!XDjSi!TEwQIb#e#q`p
zKm!xE<4kGmnb>)Oj@_y9&<P%1=u=<QBoCeGi>OSXJDI7c?L&E^z)U8*wCAj(MaT%-
z52+t|1?S$q_uRkl{M>WzpPf!Sf#mC29sFGtA^*USLgMm;wKNo_h)6^#M#7lWF)B`n
z={OT+C_<AnL}YFgk(KCKCf6s-8nqnMS|rx2<&0V@)bbL!;mD6)l$o4Xi5G1*n+Z{>
zX#%{}MNIkPY(A&R7&S(D?92Gw>!Ed~>r}VCD{@uUlt@&IOWO6M7|k;qnYpo-;d2Ux
z4^tuu(-I?65-ZXYca4P&v4si3mNC}D=~d@0YKoi~?2g2u!?B2#RCH@%IDS=9RNbOT
z+OU#{(#6w28R1xCjakNshw6PuV12AA#jYt<s8x~Q?cNxTo)~yfg@FdnMl?Ap376%V
zC@XS&phr?~YRRF2wxH10(<5}Lsyvv8O9@RC+JXapeZ^H0R<;jZ(5_3$z?r0`%4&Z^
zm1D91oY1*+`K?1^IujAa)Sf4H)(X`%xIl#J7J1A&)}R3BT6JC!5|Owh2)bPm;z@Bh
zhGmB!d@vk|<ysWnvCaVgIwL1E#R;DZ>Y1_&3Cdlu6bMRIJp|-7S>kF|Xo_=AH?0uJ
z(oL(Ftue$>`){nzb;q7t#EG+ES~~z_Q=A}7287Axgc;@xA?_{(!H|Q(L(eV3vq6O+
zycQ7A6d9*P%Fsq?j2@?MP|#YEL}oT$tMmg0_AN;wTi}?0F+^^h-cKf&ac0}mECpU=
zFK`qTwrE7rYI1Pnj0o0Zj7E*qBA)_2k-#?vD?vRgNx*NP&8uoT9+55P(GU+KX%%M4
zv|pH|vQWF3L;pM?g}Dmf6YMzKLq6uB^dO*q1vF!V8|Os&Cag)N?%2k;d-NR#OC~H(
zZ&8kF;F)qstPt%tP%%qV(W+_-P2-l*dGC|o(1kVpjM{b$j+^^S*1%41+CFnkQ-&8|
z<rMr+a3e(}kF!@N3PPKr{r(NgzKrD!>irGs$}*y{{2xdglsC06Aq|49|3p&ViKOO^
z#A3-2Nj%|}{{^b!ap-ncizu2pB5T)mPELr@sLo3XF;`(#q@h?OD(P%YRyCc8M}`zc
zMd#F^n5^mcOOe>HbXrlsN3l1Oaza5X1B)Dvd#nmd&`^85MwDW5T-GE-fU$+#G&ZwR
z=fS@T#uQXSx0x$eQK#Iwl(S~E@KkN7ZJ`&bhZfZhTfaq?Dyr{Z{pAmrYHC+_;;31y
zaLre^ro~4UO-qM7pZPxZ&9T`-p^T$(sje|iWuREsIeG4JW!++B(|l!9y8BUO^UUQ%
z-|O?f*FR?-`FfTP{2(2fp{Fn0wLRYJ$}|M#y5<`~nTF2H-eZ$zmiD@)lJ}Bnd5+2M
z?U+2XVj(sAr~LQ)>BDI?TYYrWx^5x0bq|;a-RXUwxjuExsM&)Z*}71+rgM@9?t`AM
zYuly+GhH*0+3ru?$<($@+JOAEqV}8W1DVFoIrR^tzaRaI`KtR*_1QNrW{>q{I^WB<
zE@i9xGmd^3z}@_HO=$YyOkj?kedUv`OigH#2lCI#>bu8(HId;De79Oj_5{9LwUgRT
zwGNQ_!e{TPV81xd0{zl&@7c|Md4dJn>#-<kV#;nLXby%%4WV!AUiTmi5*$^<!fmob
zH*hZWt&pXg)-lU@RBYbjQS)|7)_S3(*rVPiVeqLy@qi>@PGo^vL^$WeR?z~K7vXdd
z+e99yU9<rOiv{WsD}Xx393H1$+b5}7sjfr|bHa=S{hi@`!^ZrY*;Y7`!E2H2d@OjP
z?R+IwuzHa$_ymX=h==J_(6kMMeaIMi=@k(bPGape9%lx$4{5_<bSj!Zt__vfcWJN-
z0W@5Y;zQb4s%g7jwQgm46(%#zx?AKM$APS)VUk+n9gBS3JYP3m_1ita-ZQP-uTOU^
z@Gl#Zc|oA)R6xPAR0$wy$3>$XbGvgpuQ4~3Oh^Kp@(>iIns?s*Cg&SC+#w+4F;MUC
zPrtLkA9;}&q?mv=xQt5pR1~z4<TIkM$=UOC6o&5~NPn=vdtN9CPC&ui?(Oh~yq(@-
z%R6XAov9V^;g}{5L0Fhq4d2eHQNn%}k!jjdKR(RX`{$|`_>LC}jWu95pjkE|+wD!I
z+5{ybjlfBokkr(Xo#8MU-+np}sce1A%&7(5|0EC?B^xeu2?|r>*<Gks2&YNGX@&>}
ztlI^WqUl&EycWW5)4hU&HiJf3LOyK<Y9G?uUI6p1eygKyA^`{tM<C$3Oepx>@sBc>
z$p{4wJVpCLsd_Us*&0mwLJzGuukOfs^>-t(Dya(I`*O!-5KBgIWRpgt(vT)66L1n3
zAyNml>DFj6p-H2fieN&>lXHQaay5HBO|B;6k6<A65|APX=&V|FHq1L49;C9)7P$P_
z>ShL)9L|qV|KjxB!*|~LmVp|$gyl|(2Q}0Ei>}srS1Z^-Ch+zGfBstz7>s@!Yq<7w
zb(fp@qnqpUSht)Z|2JB}`$Aq{5dKn)WpyLRpmYOX%9|*ZEh4TjGTmIHF63|fsn(}i
z@K%15wb~D4CxJI?3cTf!!-W!WC@1lE7x;@P@dlK5!-jGW#@-_4|6Tl)vikie?SYd)
z<peCE%u(qwp%mq7*CYj=F9h?Fp{9a6!?|6b0fe+^E2IVU$Olq}Z-hvy^-14o!t($|
zcpl&QJmKYY1*qoZ0X!05s0GOgP`TceCFl*bwFMNsNTqDXM=)sbT*fDhGI$>{@y=_k
zFsMioyya=vBMAY9YfBy58T7Ipe+<*ACxH|xa|!aJ_Zw%b9`Q#@L)-Cey>|xUx@}G?
zQzGAcz@Mt}``>SAX}Mw#01d)_`!agPGEnAJcT-t~<TW9Z7!zVrVo<xjlj@f1BO!o?
zcLFfe*q*KLn2Rj%$9K@(?;oi~MCvH~5G%}s25rxkgKf)yFOOS;p@QWw2&UT0t6$kp
z@-raUm90PZdG`W;)<CY;v#a#l9KtmpM}kVMyoRI;3C5kuTS(3$!Bbkfhy>kt>FcE*
z>yY3e>Z?F*lU17Lj;!)D*NmhENeD^XD$jDg)T)E!`he1$f0bvT)=qP;tU>!Z%2=y0
z9KNo`BXU9zJa(NQPRJVK2(PqPqY9o*#>;B%?G!KVI*%}RN8rM0tO%b7bQT9FS?~t`
zYVN7_H3eNK23bZ3vcgal1@ETR?!S?ybqhl|r<rvE*}9{Va%J{4uM^1E-=x~8bJX<l
r#h1MEFL~DqeyxZUVI7mHzcBSnY}Ku^KR^G|^B-MUVF<h5*w23f9ik?c
literal 0
HcmV?d00001
diff --git a/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/GotsisWasili_2/__pycache__/stringCalculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a37db71ef9cd99b8c9c9f6794e641eac1bc8cf9
GIT binary patch
literal 6649
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
XvDNp_|KQ?xFMj{h3PaciU6}s@xetKZ
literal 0
HcmV?d00001
diff --git a/Other/GotsisWasili_2/my_calculator.py b/Other/GotsisWasili_2/my_calculator.py
index ab49b59..c4fe03d 100644
--- a/Other/GotsisWasili_2/my_calculator.py
+++ b/Other/GotsisWasili_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
import unittest
-
+from TDD_StringCalculator import IStringCalculator
from TDD_StringCalculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/GotsisWasili_2/your_calculator.py b/Other/GotsisWasili_2/your_calculator.py
index 9742055..e2a8d70 100644
--- a/Other/GotsisWasili_2/your_calculator.py
+++ b/Other/GotsisWasili_2/your_calculator.py
@@ -1,12 +1,13 @@
import unittest
from stringCalculator import StringCalculator
+from stringCalculator import IStringCalculator
#mplementierung der Testklasse für StringCalculator
class TestStringCalculator(unittest.TestCase):
def test_implements_interface(self):
c = StringCalculator()
- self.assertIsInstance(self.c, StringCalculator)
+ self.assertIsInstance(self.c, IStringCalculator)
def test_add_empty(self):
c = StringCalculator()
diff --git a/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/PikkemaatLasse_2/__pycache__/stringCalculator.cpython-312.pyc
index f8f6330f0744cb9f2196855a68b226d8671fd74e..1ff7783d8414bad0c1e6d27e8b601993b67297fe 100644
GIT binary patch
delta 22
ccmexu{M(rKG%qg~0}yyU`j|d_Bkwy&09-x@IRF3v
delta 22
ccmexu{M(rKG%qg~0}w>=e@uVBk@uY>09WM)%>V!Z
diff --git a/Other/PikkemaatLasse_2/my_calculator.py b/Other/PikkemaatLasse_2/my_calculator.py
index 1397276..4ec2a93 100644
--- a/Other/PikkemaatLasse_2/my_calculator.py
+++ b/Other/PikkemaatLasse_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von PikkemaatLasse auf meinen Testfälle: StringCalculator
import unittest
-
+from src.interfaces import IStringCalculator
from src.stringcalculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc b/Other/PikkemaatLasse_2/src/__pycache__/interfaces.cpython-312.pyc
index ac53ca6f524d1c5c8f88faf49192e432080c7686..699a52065ec2a07ec55dbe872ca09053b4c97c0e 100644
GIT binary patch
delta 20
acmbQjI)#<{G%qg~0}#kKeA>v}$pio}BLu<#
delta 20
acmbQjI)#<{G%qg~0}!0x{;-j|lL-Jbj|DdX
diff --git a/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc b/Other/PikkemaatLasse_2/src/__pycache__/stringcalculator.cpython-312.pyc
index d7070b361211a079a6b1902fa1be15345de2abe3..14633fbfbac1c8d5bbae2b57c32ed6e4e91a8cb0 100644
GIT binary patch
delta 20
acmZqRZ{X)X&CAQh00c4)pEh!rvI77va0H(K
delta 20
acmZqRZ{X)X&CAQh00bwvKWyYKWd{H;+yxW>
diff --git a/Other/PikkemaatLasse_2/src/interfaces.py b/Other/PikkemaatLasse_2/src/interfaces.py
new file mode 100644
index 0000000..53246cf
--- /dev/null
+++ b/Other/PikkemaatLasse_2/src/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/Other/PikkemaatLasse_2/src/stringcalculator.py b/Other/PikkemaatLasse_2/src/stringcalculator.py
new file mode 100644
index 0000000..fc7e89a
--- /dev/null
+++ b/Other/PikkemaatLasse_2/src/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/Other/PikkemaatLasse_2/tests/test_stringclaculator.py b/Other/PikkemaatLasse_2/tests/test_stringclaculator.py
new file mode 100644
index 0000000..e2e765b
--- /dev/null
+++ b/Other/PikkemaatLasse_2/tests/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/Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc b/Other/RafehDaniel_2/__pycache__/stringCalculatorDaniel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4716d2ae5e17a9434dc49e7abc56a57608db4e95
GIT binary patch
literal 8056
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
literal 0
HcmV?d00001
diff --git a/Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc b/Other/RafehDaniel_2/__pycache__/stringCalculatorr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44061ca184162b9ad3b7368054757a969e63e88e
GIT binary patch
literal 6649
zcmd^DT~Hg>6~6l?t%PKL?I6sLY&WrGiyujV9pgU?8QYl{#|AsLO0to)Yb;w5bayG%
zj+nX~cZ#R(IO()Cou*UzR5Nrs^r^f$lZVdqMO3EHZD*SPJcKs_%w)n-&)Jn^BqZFt
zgoj>+Pj}Crd-tB7d(OG{Pfn+uKzs9FpAS885b|$)$Tlw1S(}2+6Cx6kijo)=q+)cC
zrtq1LGC_tW=ZMHWAR;SKGmJSV$Qo1*s1}LMQ8|NZ1u8Ewci?-4Eyrn<c+qzE5Fv6E
zO@Ozmkdu&^42dEMIzfBv%lPb}b*B4lkG?B(Q&HtmSdB^Q?P0Mmym@?1u-Ab4gh(Vv
zi6lr%j7UkWNK4!;76f9m9|&3!tcTMpFZ8Q&BtFy=iiSs{A$3^Rt?|*=O-WXCi!7<5
zay(3L{tWa{9c!%dl?0il`lfM#tRh8k$yT5$$nSP<sNv&-R~49O@O(&(geBodBq~Pa
zNNliIQtqn5BZF;zVW78H=vI`-P&_8ZRYhp?4-O1$CP_#P3|>-iOY-2A&@Jh9Zzvv-
zqJn=Abdk4mxn(4wGa*sbc5jiY1<0r&1>rvVly|H_hxB=@Ixh(EP)rg8-7W~RVR1By
zeTN`?Ycv!!-^eJf&cFwCCK6ZWUGONEA(SIH5iD6iUS&VP1G2<buh10doD8fG_?Zf<
z;?EjGEH$4a-5ic1^Gt~|U|XvPcwtH~Bm;(IO+yAb!+;fq_A_iC^Dr{ca5f+qhWj0b
zb0#T;N>EAa4m=e$k)Fv=<tE_3Q3Xw8vK-@dk`mb@T}Q^5B$cE^P6J+%z%v!6MGI2z
zWL<O9EFzO+W-^X7j_W|rDQLivS;sh=WP8bDE=&)BRPTaX#yJ%wGFp<$@`={Fb)bCe
zQB|?GAJUH+Su)O!b9u8ttN;opQg>lJFxHmjfYSk-7NA??BPv?jXd>+2J812KrlK1d
zO|8iGl9sG|+134m{4%H6?@?-Xj+4!D^n-L1{Eu^En|dC5pNy)~=+@Q^%D#;KWz@_D
z<&As>=Fwj1lZIfAeOpr8@nO{+ibjXWB=NXgqrGmAUAHT0NLH1xh<aORZ$;vwZk45x
zXecb{oH7!PsB#U=rrWQDqNCCqvJ63hy)zt%>r5;(BI7#2_eWzMtBldja4@|}l%kPX
zM3rPA8i`AS1hd+5G@XSYqUa2uZi{CZr=XGDW-~VpZX~Uy(1mfcVgy${1GrEATE1tg
zx@N^f9My|u4fACUlj8HT155i3{igoc^-sn0zCg;+xK!ITMWyz)r)oPUE-dY7NHw<2
z`sN$kQ;i*|J)IBFeOkMB;sVT3UH7E*!`7*9Jhi2({1eut@;#5oAC6DnNS7a+VB!6%
zp1+izob3N?&nz=@evVChPyB@Wpy#K2s{G^x3t+O;v`_Xw?U~&-bMD9eshai)8^Axy
zYW`DIpK9uyRsWFqed3eqPx}ApNp}yVk6ul6UQ0E+ldig+a$H}xkc#RL+JBfx@wH#B
z?j{wdzFf7C-5p9T2>Yy|y2r^r^Em-OX6-#y?8oISV4ue#qi4yL2$(kvvlw<O8jbcK
z3j*#EWjDYBvO@3WTo{VrXDYCcKV|?zzPtdG4GL@T!<)?k=m7~r2m-`hLV}#g0$M~!
zi9xGq0pvwUgh89g1KLF!V3}wKbckhuPSF9lOLPL3i@N|T66Kx>y=FjC)Iu)^XIBAh
zAn5Z(_}Xu*NX@;==CdRba<l}I(S1C$p#j|<&Ly{L%5Y%?S>1*U!VZwst0P)nu_d$^
z?;v3l1wH>h`Fq{rbe(sC{ZYB0xx6J}lrxqXgbqYlQY^Lt6-6m%MI$7YjS3KtGh?7C
zAReYqCq_J&X7sX<0vT3)15=gkg;`B!XolWq87o!LuOP)n)Pw*@46>&7T2Xno@EyUK
z_5s`{OT1%|ubt;>Cu@Gy^z)`gmv`RfeR?JBYMb4+z_;(HLMWdMfuG1eghJ`745<{5
z8Zx_C+-L_&i=W5X@-q4R(=OkvZ-MXFN%=L#=k+h6^A*=Xg`oj;Y&avnqP<#L{!MJC
z&TXxKHSG$_US8mj?x^%Oklq{cwtG94je4x87wk545F3rEk&&DqDB9uDiYVl5f0;JE
znRdNC=U?DY?Wi_5pB=QZY}BJgHQ_Qek*V?ptO|s<G=^DRYbmXbV*E!zBWv45hwEuq
z=Nz@bAKy`p*gzxpfW6(`A$OJBBL}u><%I*7>QS^~|D%4kj6D7_-x1QTlXLO{e|D>;
z(2_=CS%OZf#G>ZXN;YkDKnV`%CVQBGvDsFv*cNl?#yA8+3I8JLz%039J39v<FUsQY
zP(_cunS7j|z77x{q^2<_b8ip|{vNg7V{VW!3euWp@p+rUbv0Lsa<<t&ZPguS%DWPZ
zD3T((VLh7?pC2EMg4HJ73rizvWH>%e8#!OMhKJ*-bWhEkPtELKV_H2^p=Ps#XB#u;
zvz~+xDpvs@KRPQHosIL(#*ehL^DrFvY=@r?EjcP4UwU|H(a|*TXqw`mJ3L=7@B+@C
zW-k4xdh(schL-t;mb9xi<$G&^zxV|Q494({H9UFztiIdLJacp19&28`@qgnM5Z=Kp
znjyez4JAFp>uwIny=eY(XcF8F?o5T(XxMnumNd^wxm*}1ZS9hS&f-T(*}b{Y?q$y%
zUbK62DZ9VDz+XnYH>2H~H{>^A`aENQeZ{3_ZEfwc`?~z{F<3<Ldcw@5;Za2$jtRL#
z-*&mQkk>HMc9|oXb{(68y7I)<c=$Ey!j{p6Js_Vdsg3=He-%oYpIDEU_OWdTq9bgZ
zVc$)=y5^t)JH4ZNDr;>`+I>lXGLURv#<N#(zd5pvre16{^ZHRc^Ho(=IKxF)$F|k$
zdui8+xtj}o_m1k$;`jR6+I+IBq}t2?mMy@BWGRH#F6!-2T!4{n+BN~K<e<0lYiAI!
zWZtP*W5@mF?|O;+?S|Ww6vf<Wh1*EGP}+aK;#B>prpsAf^?51_?_%(jC<hQa5ne|)
zfp8iDbA@~X;Vpzd1VjA;*t>>s9RZWQVGZ+c>@Yqe9E5)bM?D~`aBJMWYN5CegieHG
z2&WOc5PGOp3&ZtMt9FLF0!VQuk$eWo6nECZt~G;TehNQ;SKzTwBrXVWS;&NLhGpX@
ziIt<ykH#Y^>fgNJ#;YQoN6q$x;O4<tV+GP!oS;C24gQ3ApMFYy4|uR1R8W^I3`J4@
zAP4?N%GX(ja!xYq1b)`-^^`01%As`vzw0NOsWa5%vBkaK`MutCf=?^&Q-pO)Xn$s0
XOKj!+^FO%w-HYG9w89X!&JgCm`6qy!
literal 0
HcmV?d00001
diff --git a/Other/RafehDaniel_2/my_calculator.py b/Other/RafehDaniel_2/my_calculator.py
index 29b3e3c..6a58a72 100644
--- a/Other/RafehDaniel_2/my_calculator.py
+++ b/Other/RafehDaniel_2/my_calculator.py
@@ -1,14 +1,14 @@
#Umsetzungen von RafehDaniel auf meinen Testfälle: StringCalculator
import unittest
-
-from stringCalculator import StringCalculator
+from stringCalculatorDaniel import IStringCalculator
+from stringCalculatorDaniel import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/RafehDaniel_2/stringCalculatorDaniel.py b/Other/RafehDaniel_2/stringCalculatorDaniel.py
new file mode 100644
index 0000000..232cb01
--- /dev/null
+++ b/Other/RafehDaniel_2/stringCalculatorDaniel.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/Other/RafehDaniel_2/your_calculator.py b/Other/RafehDaniel_2/your_calculator.py
index 64929f3..6019b88 100644
--- a/Other/RafehDaniel_2/your_calculator.py
+++ b/Other/RafehDaniel_2/your_calculator.py
@@ -1,14 +1,15 @@
#Meine Implementierungen auf Testfälle anderer Studierenden testen: StringCalculator
import unittest
-from stringCalculator import StringCalculator
+from stringCalculatorr import IStringCalculator
+from stringCalculatorr import StringCalculator
class TestStringCalculator(unittest.TestCase):
def setUp(self):
self.c = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.c, StringCalculator)
+ self.assertIsInstance(self.c, IStringCalculator)
def test_empty(self):
res = self.c.add("")
diff --git a/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/SerchimoMarvin_2/__pycache__/stringCalculator.cpython-312.pyc
index 481f23d725110b6364206a29d305bd4d7b6eaeed..8e3cc51fd5330f136d0658f11bb259688b766189 100644
GIT binary patch
delta 22
ccmexu{M(rKG%qg~0}yyU`j|d_Bkwy&09-x@IRF3v
delta 22
ccmexu{M(rKG%qg~0}w>=e@uVBk@uY>09WM)%>V!Z
diff --git a/Other/SerchimoMarvin_2/feature7 b/Other/SerchimoMarvin_2/feature7
new file mode 100644
index 0000000..92de925
--- /dev/null
+++ b/Other/SerchimoMarvin_2/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/Other/SerchimoMarvin_2/your_calculator.py b/Other/SerchimoMarvin_2/your_calculator.py
index 7fcb668..eee47dc 100644
--- a/Other/SerchimoMarvin_2/your_calculator.py
+++ b/Other/SerchimoMarvin_2/your_calculator.py
@@ -1,8 +1,9 @@
#Meine Implementierungen auf Testfälle anderer Studierenden testen: StringCalculator
-import re
+
import unittest
from stringCalculator import StringCalculator
+from stringCalculator import IStringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -13,7 +14,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string_returns_zero(self):
"""Feature 1: Leerer String soll 0 ergeben"""
diff --git a/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc b/Other/WeishauptOrlando_2/__pycache__/stringCalculator.cpython-312.pyc
index 2075e23bed85e561a84eea481d9e4a3faf3ec4a0..95ac742fff298ee9d4b7911398f53bd26a396db8 100644
GIT binary patch
delta 22
ccmexs{MVTGG%qg~0}yyW`j|d_Bku=E09>C4KmY&$
delta 22
ccmexs{MVTGG%qg~0}w>=e@uVBk@tfn09ZW-(*OVf
diff --git a/Other/WeishauptOrlando_2/my_calculator.py b/Other/WeishauptOrlando_2/my_calculator.py
index 6dd72eb..5779122 100644
--- a/Other/WeishauptOrlando_2/my_calculator.py
+++ b/Other/WeishauptOrlando_2/my_calculator.py
@@ -1,6 +1,6 @@
#Implementierung von WeishauptOrlando auf meinen Testfälle: StringCalculator
import unittest
-
+from src.interfaces import IStringCalculator
from src.string_calculator import StringCalculator
class TestStringCalculator(unittest.TestCase):
@@ -8,7 +8,7 @@ class TestStringCalculator(unittest.TestCase):
self.calculator = StringCalculator()
def test_implements_interface(self):
- self.assertIsInstance(self.calculator, StringCalculator)
+ self.assertIsInstance(self.calculator, IStringCalculator)
def test_empty_string(self):
self.assertEqual(self.calculator.add(""), 0)
diff --git a/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc b/Other/WeishauptOrlando_2/src/__pycache__/interfaces.cpython-312.pyc
index 6219bfc375082ce2fd1f73bcfd756ebca8b34d4b..58e113c36227bb8ef2a40cf10efecfa8c4562fd1 100644
GIT binary patch
delta 20
acmaDX@K}KRG%qg~0}ymtecH$!!2tk2<OQ+-
delta 20
acmaDX@K}KRG%qg~0}!O~eAvhx!2tk0(FI=s
diff --git a/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc b/Other/WeishauptOrlando_2/src/__pycache__/string_calculator.cpython-312.pyc
index 3598fbabdabad4ddd589f69bedaf1572f553b5e0..425b6d2c856c6a059a603abc18addc47796850a6 100644
GIT binary patch
delta 20
acmaDQ^h${PG%qg~0}ymsecH$!&j|oQOa;vV
delta 20
acmaDQ^h${PG%qg~0}!P1eAvhx&j|oOIR$zE
diff --git a/Other/WeishauptOrlando_2/src/calculator.py b/Other/WeishauptOrlando_2/src/calculator.py
new file mode 100644
index 0000000..f4b4785
--- /dev/null
+++ b/Other/WeishauptOrlando_2/src/calculator.py
@@ -0,0 +1,44 @@
+import re
+from src.interfaces import ICalculator
+
+
+class Calculator(ICalculator):
+ """Ein Taschenrechner, der mathematische Ausdrücke berechnet."""
+
+ def calculate(self, expression: str) -> float:
+ """Berechnet einen mathematischen Ausdruck als String und überprüft auf ungültige Eingaben."""
+ try:
+ # Entfernt überflüssige Leerzeichen
+ expression = expression.replace(" ", "")
+
+ # Nur erlaubte Zeichen (Zahlen, Operatoren, Klammern) und Zahlen mit Vorzeichen
+ if not re.match(r'^[0-9+\-*/().]+$', expression):
+ raise ValueError("Ungültige Zeichen im Ausdruck.")
+
+ # Überprüfung auf doppelte Operatoren, aber keine Vorzeichen wie -* oder -+
+ # Hier wird jetzt auch sichergestellt, dass -3*-3 gültig bleibt
+ if re.search(r'(?<!\d)[+\-*/]{2,}', expression): # Erfasst auch doppelte Operatoren wie ++, --, **, etc.
+ raise SyntaxError("Ungültige doppelte Operatoren im Ausdruck.")
+
+ # Sicherstellen, dass Klammern ausgeglichen sind
+ if expression.count("(") != expression.count(")"):
+ raise ValueError("Fehlende oder zu viele Klammern.")
+
+ # Sicherstellen, dass der Ausdruck nicht mit einem Operator beginnt oder endet,
+ # aber das Minuszeichen als Teil der Zahl akzeptiert wird
+ if re.match(r'^[*/]', expression) or re.match(r'[*/]$', expression): # Weitere Kontrolle
+ raise ValueError("Der Ausdruck darf nicht mit einem Operator beginnen oder enden.")
+
+ # Evaluierung des mathematischen Ausdrucks mit eval()
+ result = eval(expression, {"__builtins__": None}, {})
+
+ # Sicherstellen, dass das Ergebnis numerisch ist
+ if isinstance(result, (int, float)):
+ return float(result)
+ else:
+ raise ValueError("Ungültiger Ausdruck.")
+
+ except ZeroDivisionError:
+ raise ZeroDivisionError("Division durch Null ist nicht erlaubt.")
+ except (SyntaxError, TypeError, NameError) as e:
+ raise ValueError(f"Ungültiger mathematischer Ausdruck: {str(e)}")
diff --git a/Other/WeishauptOrlando_2/src/interfaces.py b/Other/WeishauptOrlando_2/src/interfaces.py
new file mode 100644
index 0000000..be069d6
--- /dev/null
+++ b/Other/WeishauptOrlando_2/src/interfaces.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/Other/WeishauptOrlando_2/src/string_calculator.py b/Other/WeishauptOrlando_2/src/string_calculator.py
new file mode 100644
index 0000000..2cf5afb
--- /dev/null
+++ b/Other/WeishauptOrlando_2/src/string_calculator.py
@@ -0,0 +1,61 @@
+# Implementierung von IStringCalculator
+
+from src.interfaces 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/Other/WeishauptOrlando_2/tests/TestCount_ED.py b/Other/WeishauptOrlando_2/tests/TestCount_ED.py
new file mode 100644
index 0000000..152bccd
--- /dev/null
+++ b/Other/WeishauptOrlando_2/tests/TestCount_ED.py
@@ -0,0 +1,34 @@
+import unittest
+import sys
+import os
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+from src.Count_ED import Counter
+
+class TestCounter(unittest.TestCase):
+ def setUp(self):
+ self.c = Counter()
+
+ def test_count_ed_regular(self):
+ self.assertEqual(self.c.count_ed("Decker"), 3)
+
+ def test_count_ed_empty(self):
+ self.assertEqual(self.c.count_ed(""), 0)
+
+ def test_count_ed_wo(self):
+ """Testet einen String ohne E und D"""
+ self.assertEqual(self.c.count_ed("Hallo"), 0)
+
+ def test_count_ed_case_insensitive(self):
+ """Testet verschiedene Groß- und Kleinschreibungen"""
+ self.assertEqual(self.c.count_ed("Der Esel"), 4)
+
+ def test_count_ED_single_letter(self):
+ """Testet Eingaben mit nur einem Buchstaben"""
+ self.assertEqual(self.c.count_ed('D'), 1)
+ self.assertEqual(self.c.count_ed('E'), 1)
+ self.assertEqual(self.c.count_ed('d'), 1)
+ self.assertEqual(self.c.count_ed('e'), 1)
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Other/WeishauptOrlando_2/tests/__init__.py b/Other/WeishauptOrlando_2/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/Other/WeishauptOrlando_2/tests/test_calculator.py b/Other/WeishauptOrlando_2/tests/test_calculator.py
new file mode 100644
index 0000000..f0b7b03
--- /dev/null
+++ b/Other/WeishauptOrlando_2/tests/test_calculator.py
@@ -0,0 +1,103 @@
+# Testfälle für calculate(), Eingabe: str, Ausgabe: float/int
+
+# 1ï¸âƒ£ Additionstests
+# Eingabe: "1+1" → Erwartete Ausgabe: 2
+# Eingabe: "10+20" → Erwartete Ausgabe: 30
+# Eingabe: "0+5" → Erwartete Ausgabe: 5
+# Eingabe: "-3+7" → Erwartete Ausgabe: 4
+# Eingabe: "2.5+2.5" → Erwartete Ausgabe: 5.0
+
+# 2ï¸âƒ£ Subtraktionstests
+# Eingabe: "5-3" → Erwartete Ausgabe: 2
+# Eingabe: "10-20" → Erwartete Ausgabe: -10
+# Eingabe: "0-5" → Erwartete Ausgabe: -5
+# Eingabe: "-3-7" → Erwartete Ausgabe: -10
+# Eingabe: "2.5-1.5" → Erwartete Ausgabe: 1.0
+
+# 3ï¸âƒ£ Multiplikationstests
+# Eingabe: "2*3" → Erwartete Ausgabe: 6
+# Eingabe: "10*0" → Erwartete Ausgabe: 0
+# Eingabe: "-2*5" → Erwartete Ausgabe: -10
+# Eingabe: "3.5*2" → Erwartete Ausgabe: 7.0
+# Eingabe: "-3*-3" → Erwartete Ausgabe: 9
+
+# 4ï¸âƒ£ Divisionstests
+# Eingabe: "10/2" → Erwartete Ausgabe: 5
+# Eingabe: "5/2" → Erwartete Ausgabe: 2.5
+# Eingabe: "-6/3" → Erwartete Ausgabe: -2
+# Eingabe: "7.5/2.5" → Erwartete Ausgabe: 3.0
+# Eingabe: "5/0" → Erwartete Ausgabe: ZeroDivisionError (Fehlermeldung)
+
+# 5ï¸âƒ£ Komplexe Berechnungen
+# Eingabe: "3+5*2" → Erwartete Ausgabe: 13 (Multiplikation vor Addition)
+# Eingabe: "(3+5)*2" → Erwartete Ausgabe: 16 (Klammer zuerst)
+# Eingabe: "10-4/2" → Erwartete Ausgabe: 8 (Division vor Subtraktion)
+# Eingabe: "3+(2*5)-8/4" → Erwartete Ausgabe: 10 (Mehrere Operatoren)
+
+# 6ï¸âƒ£ Ungültige Eingaben
+# Eingabe: "3++5" → Erwartete Ausgabe: SyntaxError (Fehlermeldung)
+# Eingabe: "10*/2" → Erwartete Ausgabe: SyntaxError (Fehlermeldung)
+# Eingabe: "abc" → Erwartete Ausgabe: ValueError (Fehlermeldung)
+
+
+import unittest
+from src.calculator import Calculator
+
+class TestCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calc = Calculator()
+
+ # Addition
+ def test_addition(self):
+ self.assertEqual(self.calc.calculate("1+1"), 2)
+ self.assertEqual(self.calc.calculate("10+20"), 30)
+ self.assertEqual(self.calc.calculate("0+5"), 5)
+ self.assertEqual(self.calc.calculate("-3+7"), 4)
+ self.assertEqual(self.calc.calculate("2.5+2.5"), 5.0)
+
+ # Subtraktion
+ def test_subtraction(self):
+ self.assertEqual(self.calc.calculate("5-3"), 2)
+ self.assertEqual(self.calc.calculate("10-20"), -10)
+ self.assertEqual(self.calc.calculate("0-5"), -5)
+ self.assertEqual(self.calc.calculate("-3-7"), -10)
+ self.assertEqual(self.calc.calculate("2.5-1.5"), 1.0)
+
+ # Multiplikation
+ def test_multiplication(self):
+ self.assertEqual(self.calc.calculate("2*3"), 6)
+ self.assertEqual(self.calc.calculate("10*0"), 0)
+ self.assertEqual(self.calc.calculate("-2*5"), -10)
+ self.assertEqual(self.calc.calculate("3.5*2"), 7.0)
+ self.assertEqual(self.calc.calculate("-3*-3"), 9)
+
+ # Division
+ def test_division(self):
+ self.assertEqual(self.calc.calculate("10/2"), 5)
+ self.assertEqual(self.calc.calculate("5/2"), 2.5)
+ self.assertEqual(self.calc.calculate("-6/3"), -2)
+ self.assertEqual(self.calc.calculate("7.5/2.5"), 3.0)
+
+ # Division durch Null
+ def test_division_by_zero(self):
+ with self.assertRaises(ZeroDivisionError):
+ self.calc.calculate("5/0")
+
+ # Komplexe Berechnungen
+ def test_complex_expressions(self):
+ self.assertEqual(self.calc.calculate("3+5*2"), 13) # Punkt-vor-Strich beachten
+ self.assertEqual(self.calc.calculate("(3+5)*2"), 16) # Klammer zuerst
+ self.assertEqual(self.calc.calculate("10-4/2"), 8) # Division vor Subtraktion
+ self.assertEqual(self.calc.calculate("3+(2*5)-8/4"), 11.0) # 11
+
+ # Ungültige Eingaben
+ """def test_invalid_expressions(self):
+ with self.assertRaises(ValueError):
+ self.calc.calculate("3++5")
+ with self.assertRaises(ValueError):
+ self.calc.calculate("10*/2")
+ with self.assertRaises(ValueError):
+ self.calc.calculate("abc")"""
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Other/WeishauptOrlando_2/tests/test_roman.py b/Other/WeishauptOrlando_2/tests/test_roman.py
new file mode 100644
index 0000000..30cbabf
--- /dev/null
+++ b/Other/WeishauptOrlando_2/tests/test_roman.py
@@ -0,0 +1,66 @@
+# Testfälle roman_to_int, str -> int
+
+# 1. Einzelne römische Ziffern
+# Eingabe: "I" → Erwartete Ausgabe: 1
+# Eingabe: "V" → Erwartete Ausgabe: 5
+# Eingabe: "X" → Erwartete Ausgabe: 10
+# Eingabe: "L" → Erwartete Ausgabe: 50
+# Eingabe: "C" → Erwartete Ausgabe: 100
+# Eingabe: "D" → Erwartete Ausgabe: 500
+# Eingabe: "M" → Erwartete Ausgabe: 1000
+
+#2. Mehrere gleiche Ziffern hintereinander (einfache Addition)
+# Eingabe: "II" → Erwartete Ausgabe: 2
+# Eingabe: "XX" → Erwartete Ausgabe: 20
+# Eingabe: "CC" → Erwartete Ausgabe: 200
+# Eingabe: "MM" → Erwartete Ausgabe: 2000
+
+#3. Subtraktive Notation
+# Eingabe: "IV" → Erwartete Ausgabe: 4
+# Eingabe: "IX" → Erwartete Ausgabe: 9
+# Eingabe: "XL" → Erwartete Ausgabe: 40
+# Eingabe: "XC" → Erwartete Ausgabe: 90
+# Eingabe: "CD" → Erwartete Ausgabe: 400
+# Eingabe: "CM" → Erwartete Ausgabe: 900
+
+#4. Komplexe Zahlen
+# Eingabe: "MCMXCIV" → Erwartete Ausgabe: 1994
+#Eingabe: "XIV" → Erwartete Ausgabe: 14
+#Eingabe: "CDXLIV" → Erwartete Ausgabe: 444
+
+
+import sys
+import os
+import unittest
+
+# Füge das src-Verzeichnis zum Python-Pfad hinzu
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../src')))
+
+from src.RomanConverter import RomanConverter # Importiere die zu testende Klasse
+
+class TestRomanConverter(unittest.TestCase):
+ def setUp(self):
+ self.converter = RomanConverter()
+
+ def test_single_digits(self):
+ self.assertEqual(self.converter.roman_to_int("I"), 1)
+ self.assertEqual(self.converter.roman_to_int("V"), 5)
+ self.assertEqual(self.converter.roman_to_int("X"), 10)
+
+ def test_multiple_digits(self):
+ self.assertEqual(self.converter.roman_to_int("II"), 2)
+ self.assertEqual(self.converter.roman_to_int("XX"), 20)
+ self.assertEqual(self.converter.roman_to_int("VI"), 6)
+
+ def test_subtractive_notation(self):
+ self.assertEqual(self.converter.roman_to_int("IV"), 4)
+ self.assertEqual(self.converter.roman_to_int("IX"), 9)
+ self.assertEqual(self.converter.roman_to_int("XL"), 40)
+ self.assertEqual(self.converter.roman_to_int("XC"), 90)
+
+ def test_complex_numbers(self):
+ self.assertEqual(self.converter.roman_to_int("MCMXCIV"), 1994)
+ self.assertEqual(self.converter.roman_to_int("CDXLIV"), 444)
+
+if __name__ == "__main__":
+ unittest.main()
\ No newline at end of file
diff --git a/Other/WeishauptOrlando_2/tests/test_string_calculator.py b/Other/WeishauptOrlando_2/tests/test_string_calculator.py
new file mode 100644
index 0000000..b9420c0
--- /dev/null
+++ b/Other/WeishauptOrlando_2/tests/test_string_calculator.py
@@ -0,0 +1,113 @@
+# 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.string_calculator 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()
\ No newline at end of file
diff --git a/Other/report.md b/Other/report.md
index 6614ca3..75514dd 100644
--- a/Other/report.md
+++ b/Other/report.md
@@ -22,26 +22,26 @@ Testfälle anderer Studierender auf meine Implementierung: RomanNumberConverter
|SerchimoMarvin | NaN | - |
|WeishauptOrlando | No | 4x AttributeError: 'RomanNumber' object has no attribute 'roman_to_int' |
-Meine Testfälle auf Implementierungen anderer Studierender: StringCalculator
+Implementierungen anderer Studierender auf meine Testfälle: StringCalculator
| Name | Interface break | Failed Testcases |
|------------------|------------------|--------------------------------------------------|
-|AliciMuhamed | No | |
-|BerishaAlma | No | |
-|GotsisWasili | No | |
-|PikkemaatLasse | No | |
-|RafehDaniel | No | |
-|SerchimoMarvin | No | |
-|WeishauptOrlando | No | |
+|AliciMuhamed | Yes | SyntaxError: invalid syntax (gespeicherte DateiName) |
+|BerishaAlma | No | None |
+|GotsisWasili | No | FAIL: test_multiple_negative_numbers // FAIL: test_negative_number |
+|PikkemaatLasse | No | FAIL: test_add_single_negative_number // FAIL: test_add_multiple_negative_numbers // ERROR: test_add_with_custom_delimiter_multiple_characters |
+|RafehDaniel | No | FAIL: test_negative_number // FAIL: test_multiple_negative_numbers |
+|SerchimoMarvin | No | FAIL: test_custom_long_delimiter_with_negative_numbers // FAIL: test_add_negative_numbers // ERROR: test_custom_long_delimiter_with_large_number_ignored // ERROR: test_add_numbers_with_custom_delimiter_long_length |
+|WeishauptOrlando | No | 2x FAIL: test_negative_number |
-Testfälle anderer Studierender auf meine Implementierung: StringCalculator
+Meine Implementierung auf Testfälle anderer Studierender: StringCalculator
| Name | Interface break | Failed Testcases |
|------------------|------------------|--------------------------------------------------|
-|AliciMuhamed | No | |
-|BerishaAlma | No | |
-|GotsisWasili | No | |
-|PikkemaatLasse | No | |
-|RafehDaniel | No | |
-|SerchimoMarvin | No | |
-|WeishauptOrlando | No | |
\ No newline at end of file
+|AliciMuhamed | No | FAIL: test_negative_number_exception // FAIL: test_multiple_negative_numbers_exception // FAIL: test_add_numbers_greater_1000_and_minus // ERROR: test_custom_delimiter // ERROR: test_custom_del2 // ERROR: test_custom_del // ERROR: test_add_numbers_with_custom_delimiter |
+|BerishaAlma | No | None |
+|GotsisWasili | Yes | FAIL: test_add_negative_numbers / FAIL: test_add_exception / ERROR: test_implements_interface / ERROR: test_delimiters_of_any_length2 / ERROR: test_delimiters_of_any_length |
+|PikkemaatLasse | No | FAIL: test_negative_number // FAIL: test_multiple_negative_numbers |
+|RafehDaniel | No | ERROR: test_one_number_with_empty_string // ERROR: test_negative_with_positive// ERROR: test_negativeValues // ERROR: test_multidelimiter // ERROR: test_multi_negative // ERROR: test_mixture // ERROR: test_handleLetter // ERROR: test_handleFloat // ERROR: test_empty_text |
+|SerchimoMarvin | Yes | ModuleNotFoundError: No module named 'feature7' |
+|WeishauptOrlando | No | FAIL: test_add_raises_exception_on_negative_number // 2x FAIL: test_negative_number // ERROR: test_add_ignores_empty_entries // ERROR: test_add_with_multi_char_delimiter |
\ No newline at end of file
--
GitLab