Merge branch 'main' into develop

.vscode/exampleApp.py

-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)

.vscode/integrationTestExample1.py

-import unittest
-import sqlite3

.vscode/settings.json

-{
-    "python.testing.unittestArgs": [
-        "-v",
-        "-s",
-        ".",
-        "-p",
-        "*test.py"
-    ],
-    "python.testing.pytestEnabled": false,
-    "python.testing.unittestEnabled": true
-}
\ No newline at end of file

calculator.py

+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()

converter.py

+# 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()

counter.py

+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()

helloWorld.py

+print("Hello World :)")
\ No newline at end of file

main.py

-print("Hello World")
\ No newline at end of file

test.py

-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()

test_calculator.py

+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
+

unittestExample1.py

-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()
-
-
-

unittestExample2.py

-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