diff --git a/.vscode/exampleApp.py b/.vscode/exampleApp.py
deleted file mode 100644
index f703090c689b63ae91172bc73c5e64240051fa0e..0000000000000000000000000000000000000000
--- a/.vscode/exampleApp.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import sqlite3
-from flask import Flask, request, jsonify
-
-def create_app(conn):
- app = Flask(__name__)
-
- def create_user(cursor, name, email):
- cursor.execute('''CREATE TABLE IF NOT EXISTS users (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- name TEXT NOT NULL,
- email TEXT NOT NULL)''')
-
- cursor.execute('''INSERT INTO users (name, email) VALUES (?, ?)''', (name, email))
- cursor.connection.commit()
-
- def get_user(cursor, name):
- cursor.execute('''SELECT * FROM users WHERE name = ?''', (name,))
- row = cursor.fetchone()
- if row:
- return {'id': row[0], 'name': row[1], 'email': row[2]}
- return None
-
- @app.route('/create_user', methods=['POST'])
- def api_create_user():
- data = request.get_json()
- name = data.get('name')
- email = data.get('email')
-
- # Verwende 'with' für den Cursor, um sicherzustellen, dass er ordnungsgemäß verwendet wird
- with conn.cursor() as cursor:
- create_user(cursor, name, email)
- return jsonify({'message': 'User has been created successfully'}), 201
-
- @app.route('/get_user/<name>', methods=['GET'])
- def api_get_user(name):
- with conn.cursor() as cursor:
- user = get_user(cursor, name)
- if user:
- return jsonify(user), 200
- return jsonify({'message': 'User not found'}), 404
-
- return app
-
-if __name__ == '__main__':
- conn = sqlite3.connect(':memory:')
- app = create_app(conn)
- app.run(debug=True, port=8001)
diff --git a/.vscode/integrationTestExample1.py b/.vscode/integrationTestExample1.py
deleted file mode 100644
index 9f6bfd8c8539b19507f2ee56bd53da7327452bd1..0000000000000000000000000000000000000000
--- a/.vscode/integrationTestExample1.py
+++ /dev/null
@@ -1,2 +0,0 @@
-import unittest
-import sqlite3
diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index 65d939f9dd562ac3e3ac485fd26ab46ed1873838..0000000000000000000000000000000000000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
- "python.testing.unittestArgs": [
- "-v",
- "-s",
- ".",
- "-p",
- "*test.py"
- ],
- "python.testing.pytestEnabled": false,
- "python.testing.unittestEnabled": true
-}
\ No newline at end of file
diff --git a/__pycache__/calculator.cpython-312.pyc b/__pycache__/calculator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c79c8eed669ab1f2545621177cf866fa57d22f5
Binary files /dev/null and b/__pycache__/calculator.cpython-312.pyc differ
diff --git a/calculator.py b/calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a0959ccc2817bea126f1ee090960c60bcfab61b
--- /dev/null
+++ b/calculator.py
@@ -0,0 +1,66 @@
+from abc import ABC, abstractmethod
+import unittest
+
+class ICalculator(ABC):
+ @abstractmethod
+ def add(self, a, b):
+ pass
+
+ @abstractmethod
+ def sub(self, a, b):
+ pass
+
+ @abstractmethod
+ def mul(self, a, b):
+ pass
+
+ @abstractmethod
+ def div(self, a, b):
+ pass
+
+class Calculator(ICalculator):
+ def add(self, a, b):
+ return a + b
+
+ def sub(self, a, b):
+ return a - b
+
+ def mul(self, a, b):
+ return a * b
+
+ def div(self, a, b):
+ if b == 0:
+ raise ValueError("Division durch die Zahl null ist nicht erlaubt")
+ return a / b
+
+class TestCalculator(unittest.TestCase):
+ def setUp(self):
+ self.calc = Calculator()
+
+ # Test add-function
+ def test_add(self):
+ erg = self.calc.add(3, 5)
+ self.assertEqual(erg, 8)
+
+ # Test sub-function
+ def test_sub(self):
+ erg = self.calc.sub(10, 3)
+ self.assertEqual(erg, 7)
+
+ # Test mul-function
+ def test_mul(self):
+ erg = self.calc.mul(4, 6)
+ self.assertEqual(erg, 24)
+
+ # Test div-function
+ def test_div(self):
+ erg = self.calc.div(20, 4)
+ self.assertEqual(erg, 5)
+
+ # Test div/0
+ def test_div_by_zero(self):
+ with self.assertRaises(ValueError):
+ self.calc.div(10, 0)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/converter.py b/converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d5eff48258d339da12cee00fa9dd6dd640c6911
--- /dev/null
+++ b/converter.py
@@ -0,0 +1,182 @@
+# Bei Eingabe der Zahl 1 soll "I" ausgegeben werden
+# Bei Eingabe der Zahl 2 soll "II" ausgegeben werden
+# Bei Eingabe der Zahl 3 soll "III" ausgegeben werden
+# Bei Eingabe der Zahl 4 soll "IV" ausgegeben werden
+# Bei Eingabe der Zahl 5 soll "V" ausgegeben werden
+# Bei Eingabe der Zahl 9 soll "IX" ausgegeben werden
+# Bei Eingabe der Zahl 10 soll "X" ausgegeben werden
+# Bei Eingabe der Zahl 21 soll "XXI" ausgegeben werden
+# Bei Eingabe der Zahl 50 soll "L" ausgegeben werden
+# Bei Eingabe der Zahl 100 soll "C" ausgegeben werden
+# Bei Eingabe der Zahl 500 soll "D" ausgegeben werden
+# Bei Eingabe der Zahl 1000 soll "M" ausgegeben werden
+# Bei Eingabe der Zahl 1111 soll "MCXI" ausgegeben werden
+# Bei Eingabe der Zahl 99 soll "XCIX" ausgegeben werden
+# Bei Eingabe der Zahl 0 soll "Es gibt keine römische Null" ausgegeben werden
+# Bei Eingabe der Zahl 40 soll "XL" ausgegeben werden
+# Bei Eingabe eines Strings soll "Bitte ganze Zahlen eingeben" ausgegeben werden -> geändert aufgrund der Aufgabenstellung
+# Bei Eingabe von Float-Werten (z.B. 4,3) soll "Bitte ganze Zahlen eingeben" ausgegeben werden.
+# Bei Eingabe von negativen Werten (z.B. -5) soll "Es sind nur positive Zahlen zum konvertieren erlaubt" ausgegeben werden
+# Bei Eingabe der Zahl 2025 soll "MMXXV" ausgegeben werden
+# Bei Eingabe von Zeichen wie ! soll "Bitte ganze Zahlen eingeben" ausgegeben werden
+# Bei Eingabe mehrerer Zahlen wie 4, 3 soll "Bitte nur eine ganze Zahl eingeben" augegeben werden
+# Bei Eingabe größerer Zahlen wie z.B. 4000 soll "MMMM" ausgegeben werden
+# Bei Eingabe der Zahl 30 soll "XXX" ausgegeben werden
+# Bei Eingabe der Zahl 90 soll "90" ausgegeben werden
+# Bei Eingabe eines leeren Strings soll "Bitte ganze Zahlen eingeben" ausgegeben werden
+
+import unittest
+from abc import ABC, abstractmethod
+
+class IConverter(ABC):
+ @abstractmethod
+ def convert(self, num: int) -> str:
+ pass
+
+class Converter(IConverter):
+ def convert(self, num: int) -> str:
+
+ '''Sicherstellen, dass nur eine ganze Zahl eingegeben wurde.'''
+ if isinstance(num, str) and len(num.split(',')) > 1:
+ return 'Bitte nur eine ganze Zahl eingeben'
+
+ roman_numbers = [(1000, 'M'), (500, 'D'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')]
+
+ roman_str = ''
+
+ '''Wenn eine 0 eingegeben wird muss eine Exception folgen'''
+ if num == 0:
+ return "Es gibt keine römische Null"
+
+
+ '''Sicherstellen, dass keine Zeichen oder Strings eingegeben werden'''
+ if isinstance(num, int):
+
+ '''Sicherstellen, dass keine negativen Zahlen eingegeben werden'''
+ if num < 0:
+ return "Es sind nur positive Zahlen zum konvertieren erlaubt"
+
+ for value, numeral in roman_numbers:
+
+ while num >= value:
+ roman_str += numeral
+ num -= value
+
+ return roman_str
+ else:
+ return "Bitte ganze Zahlen eingeben"
+
+
+class TestConverter(unittest.TestCase):
+ def setUp(self):
+ self.c = Converter()
+
+ def test_convertOne(self):
+ res = self.c.convert(1)
+ self.assertEqual(res, 'I')
+
+ def test_convertTwo(self):
+ res = self.c.convert(2)
+ self.assertEqual(res, 'II')
+
+ def test_convertThree(self):
+ res = self.c.convert(3)
+ self.assertEqual(res, 'III')
+
+ def test_convertFour(self):
+ res = self.c.convert(4)
+ self.assertEqual(res, 'IV')
+
+ def test_convertFive(self):
+ res = self.c.convert(5)
+ self.assertEqual(res, 'V')
+
+ def test_convertNine(self):
+ res = self.c.convert(9)
+ self.assertEqual(res, 'IX')
+
+ def test_convertTen(self):
+ res = self.c.convert(10)
+ self.assertEqual(res, 'X')
+
+ def test_convertTwentyTwo(self):
+ res = self.c.convert(21)
+ self.assertEqual(res, 'XXI')
+
+ def test_convertFifty(self):
+ res = self.c.convert(50)
+ self.assertEqual(res, 'L')
+
+ def test_convertHundred(self):
+ res = self.c.convert(100)
+ self.assertEqual(res, 'C')
+
+ def test_convertFiveHundred(self):
+ res = self.c.convert(500)
+ self.assertEqual(res, 'D')
+
+ def test_convertThousand(self):
+ res = self.c.convert(1000)
+ self.assertEqual(res, 'M')
+
+ def test_convertFourDigit(self):
+ res = self.c.convert(1111)
+ self.assertEqual(res, 'MCXI')
+
+ def test_convertNintyNine(self):
+ res = self.c.convert(99)
+ self.assertEqual(res, 'XCIX')
+
+ def test_convertZero(self):
+ res = self.c.convert(0)
+ self.assertEqual(res, 'Es gibt keine römische Null')
+
+ def test_convertFourty(self):
+ res = self.c.convert(40)
+ self.assertEqual(res, 'XL')
+
+ def test_convertString(self):
+ res = self.c.convert('HUIHIN')
+ self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+ def test_convertFloat(self):
+ res = self.c.convert(4.3)
+ self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+ def test_convertNegative(self):
+ res = self.c.convert(-4)
+ self.assertEqual(res, "Es sind nur positive Zahlen zum konvertieren erlaubt")
+
+ def test_convertYear(self):
+ res = self.c.convert(2025)
+ self.assertEqual(res, "MMXXV")
+
+ def test_convertSign(self):
+ res = self.c.convert('!')
+ self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+ def test_convertMultipleNum(self):
+ res = self.c.convert('4, 3')
+ self.assertEqual(res, "Bitte nur eine ganze Zahl eingeben")
+
+ def test_convertHighNum(self):
+ res = self.c.convert(4000)
+ self.assertEqual(res, "MMMM")
+
+ def test_convertThirty(self):
+ res = self.c.convert(30)
+ self.assertEqual(res, "XXX")
+
+ def test_convertNinety(self):
+ res = self.c.convert(90)
+ self.assertEqual(res, "XC")
+
+ def test_convertEmpty(self):
+ res = self.c.convert('')
+ self.assertEqual(res, "Bitte ganze Zahlen eingeben")
+
+
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/counter.py b/counter.py
new file mode 100644
index 0000000000000000000000000000000000000000..2126ece1eae74cb5a00151852049b093f1e037e4
--- /dev/null
+++ b/counter.py
@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+import unittest
+
+# Bei Eingabe des Strings Decker liegert die Funktion 3
+
+# Bei Eingabe eines leeren Strings soll 0 ausgegeben werden
+
+# Bei Eingabe des Strings Hallo soll 0 ausgegeben werden
+
+# Bei Eingabe von Groß-/Kleinschreibung soll trotzdem der entsprechende Wert rauskommen
+
+# Bei Eingabe vom Buchstaben D oder E soll trotzdem die 1 rauskommen
+
+class ICounter(ABC):
+ @abstractmethod
+ def count_ED(self, s):
+ pass
+
+class Counter(ICounter):
+ def count_ED(self, s):
+ s = s.upper()
+ return s.count("E") + s.count("D")
+
+class TestCounter(unittest.TestCase):
+ def setUp(self):
+ self.c = Counter()
+
+ def test_count_ED_regular(self):
+ res = self.c.count_ED("Decker")
+ self.assertEqual(res, 3)
+
+ def test_count_ED_empty(self):
+ res = self.c.count_ED(" ")
+ self.assertEqual(res, 0)
+
+ def test_count_ED_wo(self):
+ res = self.c.count_ED("Hallo")
+ self.assertEqual(res, 0)
+
+ def test_count_ED_insensetiv(self):
+ res = self.c.count_ED("Der Esel")
+ self.assertEqual(res, 4)
+
+ def test_count_ED_oneL(self):
+ res = self.c.count_ED('E')
+ self.assertEqual(res, 1)
+ res = self.c.count_ED('D')
+ self.assertEqual(res, 1)
+ res = self.c.count_ED('e')
+ self.assertEqual(res, 1)
+ res = self.c.count_ED('d')
+ self.assertEqual(res, 1)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/helloWorld.py b/helloWorld.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c64f7960f82631864ef6f0c22e7e21158eadb67
--- /dev/null
+++ b/helloWorld.py
@@ -0,0 +1 @@
+print("Hello World :)")
\ No newline at end of file
diff --git a/main.py b/main.py
index 8e235769c023ae8b5dad489734aa4ac26ad526de..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/main.py
+++ b/main.py
@@ -1 +0,0 @@
-print("Hello World")
\ No newline at end of file
diff --git a/test.py b/test.py
deleted file mode 100644
index f027fd1b10d975e53ba24358ab5a225fe9bb3230..0000000000000000000000000000000000000000
--- a/test.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import unittest
-
-class Person:
- def __init__(self, name, age):
- self.name = name
- self.age = age
-
- def adult(self):
- return self.age >= 18
-
-class TestPerson(unittest.TestCase):
- def test_if_adult(self):
- person1 = Person("Daniel", 24)
- person2 = Person("Wasilios", 21)
- person3 = Person("Goksis", 12)
-
- self.assertTrue(person1.adult())
- self.assertTrue(person2.adult())
- self.assertFalse(person3.adult())
-
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/test_calculator.py b/test_calculator.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ecaa8bd747ea51031fb1bf3f37560a435ea0822
--- /dev/null
+++ b/test_calculator.py
@@ -0,0 +1,38 @@
+import sys
+import unittest
+from calculator import Calculator
+
+class TestCalculator(unittest.TestCase):
+
+ def setUp(self):
+ self.c = Calculator()
+
+ # Test add-function
+ def test_add(self):
+ erg = self.c.add(3, 5)
+ self.assertEqual(erg, 8)
+
+ # Test sub-function
+ def test_sub(self):
+ erg = self.c.sub(10, 3)
+ self.assertEqual(erg, 7)
+
+ # Test mul-function
+ def test_mul(self):
+ erg = self.c.mul(4, 6)
+ self.assertEqual(erg, 24)
+
+ # Test div-function
+ def test_div(self):
+ erg = self.c.div(20, 4)
+ self.assertEqual(erg, 5)
+
+ # Test div/0
+ def test_div_by_zero(self):
+ with self.assertRaises(ValueError):
+ self.c.div(10, 0)
+
+ # Test negative numbers
+
+ # Test wrong inputs
+
diff --git a/unittestExample1.py b/unittestExample1.py
deleted file mode 100644
index 55c1a53b46497034d83be840ffffdb85ddf19586..0000000000000000000000000000000000000000
--- a/unittestExample1.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import unittest
-
-class Person:
- def __init__(self, name, age):
- self.name = name
- self.age = age
-
- def adult(self):
- return self.age >= 18
-
-class TestPerson(unittest.TestCase):
- def test_if_adult(self):
- person1 = Person("Daniel", 24)
- person2 = Person("Wasilios", 21)
- person3 = Person("Goksis", 12)
-
- self.assertTrue(person1.adult())
- self.assertTrue(person2.adult())
- self.assertFalse(person3.adult())
-
-
-
-if __name__ == "__main__":
- unittest.main()
-
-
-
diff --git a/unittestExample2.py b/unittestExample2.py
deleted file mode 100644
index 84ff7a74104c0125ffeffb80612b17e1f2f028ff..0000000000000000000000000000000000000000
--- a/unittestExample2.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import unittest
-
-def add(a, b):
- return a + b
-
-def sub(a, b):
- return a - b
-
-def mul(a, b):
- return a * b
-
-def div(a, b):
- return a / b
-
-class TestCalculation(unittest.TestCase):
- def test_add(self):
- self.assertEqual(add(1,2), 3)
- self.assertEqual(add(8,7), 15)
- self.assertEqual(add(200, 380), 580)
-
- def test_sub(self):
- self.assertEqual(sub(2,1), 1)
- self.assertEqual(sub(8,7), 1)
- self.assertEqual(sub(380, 200), 180)
-
- def test_mul(self):
- self.assertEqual(mul(2,5), 10)
- self.assertEqual(mul(8,7), 56)
- self.assertEqual(mul(3, 20), 60)
-
- def test_div(self):
- self.assertEqual(div(10,5), 2)
- self.assertEqual(div(8,1), 8)
- self.assertEqual(div(200, 20), 10)
-
-if __name__ == "__main__":
- unittest.main()
\ No newline at end of file