diff --git a/appx/.DS_Store b/appx/.DS_Store
deleted file mode 100644
index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000
Binary files a/appx/.DS_Store and /dev/null differ
diff --git a/appx/artemis_integration.md b/appx/artemis_integration.md
deleted file mode 100644
index 67810239c6284c1c1c731f47f92d80ae1a0278c5..0000000000000000000000000000000000000000
--- a/appx/artemis_integration.md
+++ /dev/null
@@ -1,821 +0,0 @@
-## **Nutzerstudie Erstellung für ArTEMiS**
-
-Im folgenden wird Struktueriert aufgezeigt, wie mit Hilfe des Programmes 'ArTEMiS-Testgenerator' Aufgabenstellungen für die Artemis-Lernplattform in Kurse umgesetzt werden können. Der Prozess gliedert sich in folgende Schritte: 
-1. Aufgabenstellung entwickeln
-3. Aufgabenstellung für ArTEMiS optimieren
-4. Musterlösung entwickeln
-5. Testscript mit 'ArTEMiS-Testgenerator' generieren
-6. Einpflegen in ArTEMiS
-
-## **Aufgabe 1:**
-
-### **Orginal aus Altaufgabensammlug**
-
----
-
-Implementiere ein Pythonprogramm, das den Umfangs eines Rechtecks berechnet. Dabei sollen zuerst die zwei Seiten a und b mit der Funktion input eingelesen werden und anschließend das Ergebnis ausgegeben werden. Gib dem Benutzer entsprechend Auskunft, was eingelesen wird und was die Ausgabe bedeutet.
-
----
-
-### **ArTEMiS-Aufgabenstellung**
-
----
-# Implementiere ein Rechteck-Umfang-Berechnungsprogramm
-
-[task][Implementiere ein Pythonprogramm, das **den Umfang eines Rechtecks berechnet**.](test_positive_input,test_negative_input,test_large_input,test_output_contains_correct_phrase)
-Dabei sollen folgende Schritte durchgeführt werden:
-
-1. Lese die beiden Seitenlängen `a` und `b` des Rechtecks mit der Funktion `input()` ein.
-2. Berechne den Umfang des Rechtecks mit der Formel `u = 2 * (a + b)`.
-3. Gib das Ergebnis in einer verständlichen Nachricht aus, die den Benutzer über den berechneten Umfang informiert.
-
-
----
-
-### **Musterlösung**
-
----
-
-```
-# Calculates the perimeter of a rectangle based on user input.
-a = int(input("Gib bitte die Länge der Seite 1 ein:"))
-b = int(input("Gib bitte die Länge der Seite 2 ein:"))
-u = 2*(a+b)
-ausgabe = "Der Umfang des Rechtecks beträgt: "+ str(u)
-print(ausgabe)
-```
-
----
-
-### **Testgenerierung**
-
-***Mit 'Input/Output ohne Funktion' Prompt***
-
----
-
-```
-import unittest
-from unittest.mock import patch
-from io import StringIO
-import importlib
-
-class TestRectanglePerimeterBehavior:
-    """
-    Testklasse für das Verhalten der Rechteckumfangsberechnung.
-    """
-
-    def test_positive_input(self):
-        """
-        Testet die Berechnung bei positiven Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='5'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 20." in output, (
-                "Das Programm sollte positive Input korrekt berechnen und ausgeben. "
-                "Hast du überprüft, ob die Berechnung korrekt implementiert ist?"
-            )
-
-    def test_negative_input(self):
-        """
-        Testet die Berechnung bei negativen Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='-3'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter 
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 10." in output, (
-                "Das Programm sollte negative Input korrekt berechnen und ausgeben. "
-                "Wird bei negativen Werten die Berechnung richtig angewendet und die Ausgabe korrekt formatiert?"
-            )
-
-    def test_large_input(self):
-        """
-        Testet die Berechnung bei sehr großen Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='1000000'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter 
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 4000000." in output, (
-                "Das Programm sollte mit großem Input korrekt umgehen. "
-                "Hast du darauf geachtet, dass der Code keine Fehler bei sehr großen Zahlen wirft?"
-            )
-
-    def test_float_input(self):
-        """
-        Testet die Berechnung bei einer Fließkommazahl als Länge-Eingabe.
-        """
-        with patch('builtins.input', return_value='37.5'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 95.0." in output, (
-                "Das Programm sollte gleitkomma Input korrekt berechnen und ausgeben. "
-                "Überprüfe, ob die Berechnung für nicht-ganzzahlige Werte exakt ist."
-            )
-
-
-class TestRectanglePerimeterStructure:
-    """
-    Testklasse für die Struktur der Rechteckumfangsberechnung.
-    """
-
-    def test_output_contains_correct_phrase(self):
-        """
-        Prüft, ob die Ausgabe die richtige Formulierung enthält.
-        """
-        with patch('builtins.input', return_value='25'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Strukturprüfung der Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: " in output, (
-                "Die Ausgabe sollte den Text 'Der Umfang des Rechtecks beträgt: ' enthalten. "
-                "Ist sichergestellt, dass die Ausgabe einheitlich formatiert ist?"
-            )
-```
-
----
-
-### **Einpflegen in ArTEMiS**
-
----
-
-Das Einpflegen in ArTEMiS funktioniert in folgenden Schritten: 
-1. TestKlassen in den jeweils passenden vordefinierten File kopieren (behavior_test.py bzw. structural_test.py)
-2. float Testcase entfernen 
-3. Leichte Veränderungen an  den erwarteten Ausgaben machen ('.' entfernen und Ergebnis für test_negativ_input korregieren)
-
-```
-# bevavior_test.py
-import unittest
-from unittest.mock import patch
-from io import StringIO
-import importlib
-
-class TestRectanglePerimeterBehavior:
-    """
-    Testklasse für das Verhalten der Rechteckumfangsberechnung.
-    """
-
-    def test_positive_input(self):
-        """
-        Testet die Berechnung bei positiven Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='5'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 20" in output, (
-                "Das Programm sollte positive Input korrekt berechnen und ausgeben. "
-                "Hast du überprüft, ob die Berechnung korrekt implementiert ist?"
-            )
-
-    def test_negative_input(self):
-        """
-        Testet die Berechnung bei negativen Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='-3'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: -12" in output, (
-                "Das Programm sollte negative Input korrekt berechnen und ausgeben. "
-                "Wird bei negativen Werten die Berechnung richtig angewendet und die Ausgabe korrekt formatiert?"
-            )
-
-    def test_large_input(self):
-        """
-        Testet die Berechnung bei sehr großen Längen-Eingaben.
-        """
-        with patch('builtins.input', return_value='1000000'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Überprüfe die Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: 4000000" in output, (
-                "Das Programm sollte mit großem Input korrekt umgehen. "
-                "Hast du darauf geachtet, dass der Code keine Fehler bei sehr großen Zahlen wirft?"
-            )
-```
-
-```
-# structural_test.py
-import unittest
-from unittest.mock import patch
-from io import StringIO
-import importlib
-
-
-class TestRectanglePerimeterStructure:
-    """
-    Testklasse für die Struktur der Rechteckumfangsberechnung.
-    """
-
-    def test_output_contains_correct_phrase(self):
-        """
-        Prüft, ob die Ausgabe die richtige Formulierung enthält.
-        """
-        with patch('builtins.input', return_value='25'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            import assignment.rectangle_perimeter
-            importlib.reload(assignment.rectangle_perimeter)
-            output = mock_stdout.getvalue().strip()
-
-            # Strukturprüfung der Ausgabe
-            assert "Der Umfang des Rechtecks beträgt: " in output, (
-                "Die Ausgabe sollte den Text 'Der Umfang des Rechtecks beträgt: ' enthalten. "
-                "Ist sichergestellt, dass die Ausgabe einheitlich formatiert ist?"
-            )
-```
-
----
-
-
-
-
-
-## **Aufgabe 2:**
-
-### **Original aus Altaufgabensammlung**
-
----
-
-Implementiere eine Funktion, die eine Liste als Parameter erhält und die Länge der Liste zurückliefert.
-
----
-
-### **ArTEMiS-Aufgabenstellung**
-
----
-
-# Implementiere Listen längen Funktionen
-
-[task][Implementiere eine Funktion namens `list_length`, die die Länge einer Liste zurückgebt.](test_function_exists, test_list_length_for_empty_list, test_list_length_for_mixed_types, test_list_length_for_multiple_elements, test_list_length_for_single_element)
-Dabei sollen folgende Schritte durchgeführt werden:
-
-1. Erstelle Eine funktion mit dem namen `list_length`, die eine Liste als Parameter entgegen nimmt.
-2. Berechne die Länge der Liste und gib diese zurück.
-
-
-
----
-
-### **Musterlösung**
-
----
-
-```
-def list_length(lst):
-    return len(lst)
-```
-
----
-
-### **Testgenerierung**
-
-***Mit 'Einfache Funktion' (Standardprompt) generiert***
-
----
-
-```
-import unittest
-from assignment.list import ...  # Importiere den zu testenden Code
-
-class TestListFunctionBehavior(unittest.TestCase):
-
-    def test_list_length_for_empty_list(self):
-        """
-        Prüft, ob 'list_length' eine leere Liste korrekt auf 0 setzt.
-        """
-        self.assertEqual(
-            list_length([]), 0,
-            "'list_length' soll eine leere Liste auf 0 setzen. Überprüfe, ob die Funktion für einfache Listenkorrektheit funktioniert."
-        )
-
-    def test_list_length_for_single_element(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit einem Element korrekt auf 1 setzt.
-        """
-        self.assertEqual(
-            list_length([1]), 1,
-            "'list_length' soll eine Liste mit einem Element auf 1 setzen. Vergewissere dich, dass die Funktion für Listen mit einem Element funktioniert."
-        )
-
-    def test_list_length_for_multiple_elements(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit mehreren Elementen korrekt auf die Anzahl der Elemente setzt.
-        """
-        self.assertEqual(
-            list_length([1, 2, 3]), 3,
-            "'list_length' soll eine Liste mit mehreren Elementen auf die Anzahl der Elemente setzen. Überprüfe, ob die Funktion für Listen mit mehreren Elementen funktioniert."
-        )
-
-    def test_list_length_for_mixed_types(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit verschiedenen Typen korrekt auf die Anzahl der Elemente setzt.
-        """
-        self.assertEqual(
-            list_length([1, "a", 2.5]), 3,
-            "'list_length' soll eine Liste mit verschiedenen Typen auf die Anzahl der Elemente setzen. Überprüfe, ob die Funktion für Listen mit verschiedenen Typen funktioniert."
-        )
-
-class TestListFunctionStructure(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'list_length' existiert.
-        """
-        self.assertTrue(
-            callable(list_length),
-            "'list_length' soll existieren. Vergewissere dich, dass die Funktion definiert ist. Hast du überprüft, ob die Funktion richtig geschrieben wurde?"
-        )
-```
-
----
-
-### **Einpflegen in ArTEMiS**
-
----
-
-Das Einpflegen in ArTEMiS funktioniert in folgenden Schritten: 
-1. TestKlassen in den jeweils passenden vordefinierten File kopieren (behavior_test.py bzw. structural_test.py)
-2. Import mit passendem File und Funktionsnamen anpassen
-
-```
-# bevavior_test.py
-import unittest
-from assignment.list_length import list_length
-
-class TestListFunctionBehavior(unittest.TestCase):
-
-    def test_list_length_for_empty_list(self):
-        """
-        Prüft, ob 'list_length' eine leere Liste korrekt auf 0 setzt.
-        """
-        self.assertEqual(
-            list_length([]), 0,
-            "'list_length' soll eine leere Liste auf 0 setzen. Überprüfe, ob die Funktion für einfache Listenkorrektheit funktioniert."
-        )
-
-    def test_list_length_for_single_element(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit einem Element korrekt auf 1 setzt.
-        """
-        self.assertEqual(
-            list_length([1]), 1,
-            "'list_length' soll eine Liste mit einem Element auf 1 setzen. Vergewissere dich, dass die Funktion für Listen mit einem Element funktioniert."
-        )
-
-    def test_list_length_for_multiple_elements(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit mehreren Elementen korrekt auf die Anzahl der Elemente setzt.
-        """
-        self.assertEqual(
-            list_length([1, 2, 3]), 3,
-            "'list_length' soll eine Liste mit mehreren Elementen auf die Anzahl der Elemente setzen. Überprüfe, ob die Funktion für Listen mit mehreren Elementen funktioniert."
-        )
-
-    def test_list_length_for_mixed_types(self):
-        """
-        Prüft, ob 'list_length' eine Liste mit verschiedenen Typen korrekt auf die Anzahl der Elemente setzt.
-        """
-        self.assertEqual(
-            list_length([1, "a", 2.5]), 3,
-            "'list_length' soll eine Liste mit verschiedenen Typen auf die Anzahl der Elemente setzen. Überprüfe, ob die Funktion für Listen mit verschiedenen Typen funktioniert."
-        )
-```
-
-```
-# structural_test.py
-import unittest
-from assignment.list_length import list_length
-
-class TestListFunctionStructure(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'list_length' existiert.
-        """
-        self.assertTrue(
-            callable(list_length),
-            "'list_length' soll existieren. Vergewissere dich, dass die Funktion definiert ist. Hast du überprüft, ob die Funktion richtig geschrieben wurde?"
-        )
-```
-
----
-
-## **Aufgabe 3:**
-
-### **Original aus Altaufgabensammlung**
-
----
-
-Implementiere ein Programm, dass die Zahlen der übergebenen Liste [2,5,7,86,1,0] nacheinander ausgibt. Die Funktion bekommt als ersten Parameter eine 0 und als zweiten Parameter die Liste übergeben. Löse dies rekursiv.
-
----
-
-### **ArTEMiS-Aufgabenstellung**
-
----
-
-# Implementiere ein Programm zur Ausgabe einer Zahlenliste
-
-[task][Implementiere ein Pythonprogramm, das die Zahlen einer übergebenen Liste nacheinander ausgibt.](test_print_positive_numbers_rec,test_print_zero_rec,test_print_of_positive_numbers_it,test_print_of_zero_it,test_print_of_negative_numbers_it,test_function_exists_rec,test_is_recursive,test_function_exists_it,test_is_iterative)
- Dabei sollen folgende Schritte durchgeführt werden:
-
-1. Schreibe eine **rekursive Funktion** namens `print_list_recursive`, die folgende Parameter erhält:
-   - `index`: Der Startindex, der initial den Wert `0` hat.
-   - `lst`: Die Liste, deren Zahlen ausgegeben werden sollen.
-2. Die Funktion soll:
-   - Die aktuelle Zahl an der Position `index` ausgeben.
-   - Sich selbst mit dem nächsten Index aufrufen, bis das Ende der Liste erreicht ist.
-
-3. Schreibe eine **iterative Funktion** namens `print_list_iterative`, die:
-   - Die Liste als Parameter erhält.
-   - Eine Schleife verwendet, um die Zahlen der Liste nacheinander auszugeben.
-
-4. Teste beide Funktionen mit der Liste `[2, 5, 7, 86, 1, 0]`.
-5. Stelle sicher, dass jede Zahl in einer neuen Zeile ausgegeben wird.
-
----
-
-### **Musterlösung**
-
-```
-# Rekursive Funktion
-def print_list_recursive(index, lst):
-    if index < len(lst):
-        print(lst[index])
-        print_list_recursive(index + 1, lst)
-
-# Iterative Funktion
-def print_list_iterative(lst):
-    for number in lst:
-        print(number)
-```
-
----
-
-### **Testgenerierung**
-
-***Mit 'Rekursive Funktion mit Output' und 'Iterative Funktion mit Output' generiert***
-
----
-
-```
-import unittest
-from unittest.mock import patch
-from io import StringIO
-from assignment.print_list_recursive import print_list_recursive  # Ersetze mit der tatsächlichen Datei und Funktion
-
-class TestPrintListRecursiveBehavior(unittest.TestCase):
-    """
-    Testklasse für das Verhalten der Funktion 'print_list_recursive'.
-    """
-
-    def test_print_positive_numbers(self):
-        """
-        Prüft die Ausgabe bei positiven Zahlen.
-        """
-        expected_output = "1\n2\n3\n4\n5\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_recursive(0, [1, 2, 3, 4, 5])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_recursive' soll die Zahlen korrekt ausgeben. "
-                "Überprüfe, ob die Zahlen bei jedem Schritt korrekt berechnet und ausgegeben werden."
-            )
-
-    def test_print_zero(self):
-        """
-        Prüft die Ausgabe bei der Eingabe 0.
-        """
-        expected_output = "" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_recursive(5, [1, 2, 3, 4, 5])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_recursive' soll keine Ausgabe erzeugen, wenn die Eingabe 0 ist. "
-                "Falls du eine Ausgabe erzeugest, überprüfe, ob dies korrekt implementiert ist."
-            )
-
-class TestPrintListRecursiveStructure(unittest.TestCase):
-    """
-    Testklasse für die strukturellen Aspekte der Funktion 'print_list_recursive'.
-    """
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'print_list_recursive' existiert.
-        """
-        self.assertTrue(
-            callable(print_list_recursive),
-            "'print_list_recursive' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist."
-        )
-
-    def test_is_recursive(self):
-        """
-        Prüft, ob die Funktion 'print_list_recursive' rekursiv implementiert wurde.
-        """
-        import inspect
-        source_code = inspect.getsource(print_list_recursive)
-        occurrences = source_code.count("print_list_recursive(")
-
-        self.assertGreaterEqual(
-            occurrences,
-            2,
-            "'print_list_recursive' soll rekursiv implementiert sein. Der rekursive Aufruf wurde nicht gefunden. "
-            "Stelle sicher, dass die Funktion sich selbst korrekt aufruft."
-        )
-        self.assertNotIn(
-            "for",
-            source_code,
-            "'print_list_recursive' soll rekursiv implementiert sein. Schleifen (z. B. 'for') sind nicht erlaubt. "
-            "Falls du eine Schleife verwendest, ersetze sie durch einen rekursiven Aufruf."
-        )
-        self.assertNotIn(
-            "while",
-            source_code,
-            "'print_list_recursive' soll rekursiv implementiert sein. Schleifen (z. B. 'while') sind nicht erlaubt. "
-            "Falls du eine Schleife verwendest, überprüfe, wie sie durch Rekursion ersetzt werden kann."
-        )
-
-
-import unittest
-from io import StringIO
-from unittest.mock import patch
-
-
-class TestPrintListIterativeBehavior(unittest.TestCase):
-
-    def test_print_of_positive_numbers(self):
-        """
-        Prüft die Ausgabe bei positiven Zahlen.
-        """
-        expected_output = "1\n2\n3\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([1, 2, 3])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll die Elemente korrekt ausgeben. "
-                "Hast du sichergestellt, dass alle Elemente korrekt ausgegeben werden?"
-            )
-
-    def test_print_of_zero(self):
-        """
-        Prüft die Ausgabe bei der Eingabe 0.
-        """
-        expected_output = "" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([0])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll keine Ausgabe machen, wenn 0 eingegeben wird. "
-                "Wird der Sonderfall für die Eingabe 0 korrekt behandelt?"
-            )
-
-    def test_print_of_negative_numbers(self):
-        """
-        Prüft die Ausgabe bei negativen Zahlen.
-        """
-        expected_output = "-1\n-2\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([-1, -2])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll die Elemente korrekt ausgeben. "
-                "Hast du sichergestellt, dass alle Elemente korrekt ausgegeben werden?"
-            )
-
-
-class TestPrintListIterativeStructure(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'print_list_iterative' existiert.
-        """
-        self.assertTrue(
-            callable(print_list_iterative),
-            "'print_list_iterative' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist."
-        )
-
-    def test_is_iterative(self):
-        """
-        Prüft, ob die Funktion 'print_list_iterative' iterativ implementiert wurde.
-        """
-        import inspect
-        source_code = inspect.getsource(print_list_iterative)
-        self.assertNotIn(
-            "return print_list_iterative",
-            source_code,
-            "'print_list_iterative' soll iterativ implementiert sein. Es wurden rekursive Aufrufe gefunden. "
-            "Hast du überprüft, ob eine Schleife zur Ausgabe verwendet wird?"
-        )
-        self.assertIn(
-            "for",
-            source_code,
-            "'print_list_iterative' soll iterativ implementiert sein. Eine Schleife (z. B. 'for') wird erwartet. "
-            "Überprüfe, ob der Code tatsächlich iterativ arbeitet."
-        )
-```
-
----
-
-### **Einpflegen in ArTEMiS**
-
----
-
-Das Einpflegen in ArTEMiS funktioniert in folgenden Schritten: 
-1. TestKlassen in den jeweils passenden vordefinierten File kopieren (behavior_test.py bzw. structural_test.py)
-2. Import mit passendem File und Funktionsnamen anpassen
-3. TestPrintListIterativeBehavior::test_print_of_zero Erwartung von '' auf '0\n' ändern. 
-4. Doppel vergebene Namen eindeutig gemacht
-
-```
-# bevavior_test.py
-import unittest
-from unittest.mock import patch
-from io import StringIO
-from assignment.print_list import print_list_recursive
-from assignment.print_list import print_list_iterative
-
-class TestPrintListRecursiveBehavior(unittest.TestCase):
-    """
-    Testklasse für das Verhalten der Funktion 'print_list_recursive'.
-    """
-
-    def test_print_positive_numbers_rec(self):
-        """
-        Prüft die Ausgabe bei positiven Zahlen.
-        """
-        expected_output = "1\n2\n3\n4\n5\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_recursive(0, [1, 2, 3, 4, 5])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_recursive' soll die Zahlen korrekt ausgeben. "
-                "Überprüfe, ob die Zahlen bei jedem Schritt korrekt berechnet und ausgegeben werden."
-            )
-
-    def test_print_zero_rec(self):
-        """
-        Prüft die Ausgabe bei der Eingabe 0.
-        """
-        expected_output = "" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_recursive(5, [1, 2, 3, 4, 5])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_recursive' soll keine Ausgabe erzeugen, wenn die Eingabe 0 ist. "
-                "Falls du eine Ausgabe erzeugest, überprüfe, ob dies korrekt implementiert ist."
-            )
-
-class TestPrintListIterativeBehavior(unittest.TestCase):
-
-    def test_print_of_positive_numbers_it(self):
-        """
-        Prüft die Ausgabe bei positiven Zahlen.
-        """
-        expected_output = "1\n2\n3\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([1, 2, 3])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll die Elemente korrekt ausgeben. "
-                "Hast du sichergestellt, dass alle Elemente korrekt ausgegeben werden?"
-            )
-
-    def test_print_of_zero_it(self):
-        """
-        Prüft die Ausgabe bei der Eingabe 0.
-        """
-        expected_output = "0\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([0])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll keine Ausgabe machen, wenn 0 eingegeben wird. "
-                "Wird der Sonderfall für die Eingabe 0 korrekt behandelt?"
-            )
-
-    def test_print_of_negative_numbers_it(self):
-        """
-        Prüft die Ausgabe bei negativen Zahlen.
-        """
-        expected_output = "-1\n-2\n" 
-        with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
-            print_list_iterative([-1, -2])
-            self.assertEqual(
-                mock_stdout.getvalue(),
-                expected_output,
-                "'print_list_iterative' soll die Elemente korrekt ausgeben. "
-                "Hast du sichergestellt, dass alle Elemente korrekt ausgegeben werden?"
-            )
-```
-
-```
-# structural_test.py
-import unittest
-from io import StringIO
-from unittest.mock import patch
-from assignment.print_list import print_list_iterative
-from assignment.print_list import print_list_recursive
-
-class TestPrintListRecursiveStructure(unittest.TestCase):
-    """
-    Testklasse für die strukturellen Aspekte der Funktion 'print_list_recursive'.
-    """
-
-    def test_function_exists_rec(self):
-        """
-        Prüft, ob die Funktion 'print_list_recursive' existiert.
-        """
-        self.assertTrue(
-            callable(print_list_recursive),
-            "'print_list_recursive' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist."
-        )
-
-    def test_is_recursive(self):
-        """
-        Prüft, ob die Funktion 'print_list_recursive' rekursiv implementiert wurde.
-        """
-        import inspect
-        source_code = inspect.getsource(print_list_recursive)
-        occurrences = source_code.count("print_list_recursive(")
-
-        self.assertGreaterEqual(
-            occurrences,
-            2,
-            "'print_list_recursive' soll rekursiv implementiert sein. Der rekursive Aufruf wurde nicht gefunden. "
-            "Stelle sicher, dass die Funktion sich selbst korrekt aufruft."
-        )
-        self.assertNotIn(
-            "for",
-            source_code,
-            "'print_list_recursive' soll rekursiv implementiert sein. Schleifen (z. B. 'for') sind nicht erlaubt. "
-            "Falls du eine Schleife verwendest, ersetze sie durch einen rekursiven Aufruf."
-        )
-        self.assertNotIn(
-            "while",
-            source_code,
-            "'print_list_recursive' soll rekursiv implementiert sein. Schleifen (z. B. 'while') sind nicht erlaubt. "
-            "Falls du eine Schleife verwendest, überprüfe, wie sie durch Rekursion ersetzt werden kann."
-        )
-
-class TestPrintListIterativeStructure(unittest.TestCase):
-
-    def test_function_exists_it(self):
-        """
-        Prüft, ob die Funktion 'print_list_iterative' existiert.
-        """
-        self.assertTrue(
-            callable(print_list_iterative),
-            "'print_list_iterative' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist."
-        )
-
-    def test_is_iterative(self):
-        """
-        Prüft, ob die Funktion 'print_list_iterative' iterativ implementiert wurde.
-        """
-        import inspect
-        source_code = inspect.getsource(print_list_iterative)
-        self.assertNotIn(
-            "return print_list_iterative",
-            source_code,
-            "'print_list_iterative' soll iterativ implementiert sein. Es wurden rekursive Aufrufe gefunden. "
-            "Hast du überprüft, ob eine Schleife zur Ausgabe verwendet wird?"
-        )
-        self.assertIn(
-            "for",
-            source_code,
-            "'print_list_iterative' soll iterativ implementiert sein. Eine Schleife (z. B. 'for') wird erwartet. "
-            "Überprüfe, ob der Code tatsächlich iterativ arbeitet."
-        )
-```
-
----
diff --git a/appx/beispiel_optimierung.md b/appx/beispiel_optimierung.md
deleted file mode 100644
index 1fa1afb4ccf696a9a9693b4ea9969c86d930363f..0000000000000000000000000000000000000000
--- a/appx/beispiel_optimierung.md
+++ /dev/null
@@ -1,764 +0,0 @@
-## **Prompt Beispiel optimierungs Untersuchung**
-
-Es wird getestet ob ein spezialisiertes Beispiel im oneshot Prompt die Qualität der Ergebnisse verbessert. 
-
-In der folgenden Analyse wird der Einfluss eines speziellen Beispiels in der Prompteingabe hinsichtlich ihres Einflusses auf die Leistungsfähigkeit bei der Testgenerierung untersucht. Jeder Test durchlauf besteht aus drei Iterationen des gleichen Basisprompts einmal mit einem allgemeinen und einmal mit einem speziellen Beispiel.
-
-Die Ergebnisse der Modellausgabe werden anschließend mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Abschließend werden die Ergebnisse in **Auswertungstabellen** zusammengefasst und gegenübergestellt. Diese befinden sich der Übersichtlichkeit halber am Anfang des Dokuments.
-
----
-
-## **Auswertungstabelle**
-
-| **Prompt-Art**                        | **Iteration 1** | **Iteration 2** | **Iteration 3** | **Total** | **Prozent** |
-|---------------------------------------|-----------------|-----------------|-----------------|-----------|-------------|
-| **Allgemeines Beispiel**              | 6/10            | 7/10            | 7/10            | 20/30     | 66,67%      |
-| **Spezialisiertes Beispiel**          | 8/10            | 8/10            | 8/10            | 24/30     | 80,00%      |
-
----
-
-## **Allgemeines Beispiel**
-
-### **Prompt**
-
----
-
-You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-### Requirements ###
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
-### Example ###
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-```
-def fibonacci(n):
-    if n == 0:
-        return 0
-    elif n == 1:
-        return 1
-
-    a, b = 0, 1
-    for _ in range(2, n + 1):
-        a, b = b, a + b 
-    return b
-```
-
----
-
-```
-import unittest
-
-class TestFibonacciFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'fibonacci' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'fibonacci' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_fibonacci_zero(self):
-        """
-        Prüft, ob 'fibonacci' für n=0 korrekt ausgerichtet wird.
-        """
-        self.assertEqual(fibonacci(0), 0, "'fibonacci' soll für n=0 den 
-Wert '0' zurückgeben. Überprüfe die Ausgabe bei einfacher Eingabe.")
-
-    def test_fibonacci_one(self):
-        """
-        Prüft, ob 'fibonacci' für n=1 korrekt ausgerichtet wird.
-        """
-        self.assertEqual(fibonacci(1), 1, "'fibonacci' soll für n=1 den 
-Wert '1' zurückgeben. Überprüfe die Ausgabe bei einfacher Eingabe.")
-
-    def test_fibonacci_small_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' eine positive Ganzzahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(5), 5, "'fibonacci' soll eine positive 
-Ganzzahl korrekt berechnen. Überprüfe die Ausgabe bei kleinen Eingaben.")
-
-    def test_fibonacci_large_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' eine positive Ganzzahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(10), 55, "'fibonacci' soll eine 
-positive Ganzzahl korrekt berechnen. Überprüfe die Ausgabe bei größeren 
-Eingaben.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'fibonacci' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingangen 
-korrekt validiert werden."): fibonacci("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'fibonacci' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingangen 
-korrekt validiert werden."): fibonacci(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ❌
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ❌
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/8**
-
----
-
-```
-import unittest
-
-class TestFibonacciFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'fibonacci' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'fibonacci' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_fibonacci_zero(self):
-        """
-        Prüft, ob 'fibonacci' den Wert 0 bei Eingabe von 0 korrekt 
-zurückgibt.
-        """
-        self.assertEqual(fibonacci(0), 0, "'fibonacci' soll den Wert 0 bei 
-Eingabe von 0 zurückgeben. Überprüfe, ob die Implementierung für den 
-Nullfall korrekt ist.")
-
-    def test_fibonacci_one(self):
-        """
-        Prüft, ob 'fibonacci' den Wert 1 bei Eingabe von 1 korrekt 
-zurückgibt.
-        """
-        self.assertEqual(fibonacci(1), 1, "'fibonacci' soll den Wert 1 bei 
-Eingabe von 1 zurückgeben. Überprüfe, ob die Implementierung für den 
-Einheitsfall korrekt ist.")
-
-    def test_fibonacci_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' positive Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(5), 5, "'fibonacci' soll positive 
-Ganzzahlen korrekt berechnen. Überprüfe, ob die Implementierung für 
-einfache Fälle korrekt ist.")
-
-    def test_fibonacci_negative_integer(self):
-        """
-        Prüft, ob 'fibonacci' negative Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(-5), 3, "'fibonacci' soll negative 
-Ganzzahlen korrekt berechnen. Vergewissere dich, dass Vorzeichen richtig 
-behandelt werden.")
-
-    def test_fibonacci_large_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' sehr große positive Zahlen korrekt 
-berechnet.
-        """
-        self.assertEqual(fibonacci(100), 354224848179261915075, 
-"'fibonacci' soll sehr große positive Zahlen korrekt berechnen. Überprüfe, 
-ob die Implementierung für großes Ausmaß korrekt ist.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'fibonacci' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt 
-validiert werden."): fibonacci("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'fibonacci' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt 
-validiert werden."): fibonacci(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ✅
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ❌
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkung: 
-- Fehlerhafte Rechnung für Negative-Integer
-
-**Punkte: 7/8**
-
----
-
-Here is the Python test suite:
-
-```
-import unittest
-import math
-
-class TestFibonacciFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'fibonacci' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'fibonacci' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_fibonacci_zero(self):
-        """
-        Prüft, ob 'fibonacci' bei Eingabe 0 den korrekten Wert zurückgibt.
-        """
-        self.assertEqual(fibonacci(0), 0, "'fibonacci' soll für Eingabe 0 
-den korrekten Wert zurückgeben. Überprüfe, ob die Basistruppen richtig 
-berechnet werden.")
-
-    def test_fibonacci_one(self):
-        """
-        Prüft, ob 'fibonacci' bei Eingabe 1 den korrekten Wert zurückgibt.
-        """
-        self.assertEqual(fibonacci(1), 1, "'fibonacci' soll für Eingabe 1 
-den korrekten Wert zurückgeben. Vergewissere dich, dass die Rekursion 
-korrekt abgeschlossen wird.")
-
-    def test_fibonacci_small_number(self):
-        """
-        Prüft, ob 'fibonacci' bei kleineren Zahlen den korrekten Wert 
-zurückgibt.
-        """
-        for i in range(1, 10):
-            self.assertEqual(fibonacci(i), math.fib(i), "'fibonacci' soll 
-für kleinere Zahlen den korrekten Wert zurückgeben. Überprüfe die 
-Fibonacci-Folge.")
-
-    def test_fibonacci_large_number(self):
-        """
-        Prüft, ob 'fibonacci' bei größeren Zahlen den korrekten Wert 
-zurückgibt.
-        """
-        for i in range(10, 20):
-            self.assertEqual(fibonacci(i), math.fib(i), "'fibonacci' soll 
-für größere Zahlen den korrekten Wert zurückgeben. Überprüfe die 
-Fibonacci-Folge.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'fibonacci' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt 
-validiert werden."): fibonacci("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'fibonacci' bei 'None'-Eingangen einen Typfehler 
-auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt 
-validiert werden."): fibonacci(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ✅
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ❌
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/8**
-
-***Total: 20/24***
-
----
-
-## **Spezielles Beispiel**
-
-### **Prompt**
-
----
-
-You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-### Requirements ###
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
-### Example ###
-
-```
-import unittest
-
-class TestFactorialFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'factorial' existiert.
-        """
-        self.assertTrue(callable(factorial), "'factorial' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_factorial_of_zero(self):
-        """
-        Prüft, ob 'factorial' die Fakultät von 0 korrekt berechnet.
-        """
-        self.assertEqual(factorial(0), 1, "'factorial' soll für 0 den Wert 1 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_factorial_of_one(self):
-        """
-        Prüft, ob 'factorial' die Fakultät von 1 korrekt berechnet.
-        """
-        self.assertEqual(factorial(1), 1, "'factorial' soll für 1 den Wert 1 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_factorial_of_small_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fakultät einer kleinen positiven Zahl korrekt berechnet.
-        """
-        self.assertEqual(factorial(5), 120, "'factorial' soll für 5 den Wert 120 zurückgeben. Überprüfe die Multiplikationslogik.")
-
-    def test_factorial_of_large_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fakultät einer großen positiven Zahl korrekt berechnet.
-        """
-        self.assertEqual(factorial(10), 3628800, "'factorial' soll für 10 den Wert 3628800 zurückgeben. Überprüfe die Skalierbarkeit.")
-
-    def test_invalid_negative_integer(self):
-        """
-        Prüft, ob 'factorial' bei negativen Zahlen einen Fehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'factorial' soll bei negativen Eingaben einen Fehler werfen. Überprüfe die Validierung."):
-            factorial(-1)
-
-    def test_invalid_type(self):
-        """
-        Prüft, ob 'factorial' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'factorial' soll für String-Eingaben einen Typfehler werfen. Überprüfe die Typenvalidierung."):
-            factorial("5")
-
-    def test_iterative_implementation(self):
-        """
-        Prüft, ob 'factorial' iterativ implementiert ist, indem die Anzahl der Aufrufe im Quellcode überprüft wird.
-        """
-        import inspect
-        source_code = inspect.getsource(factorial)
-
-        recursive_calls = source_code.count("factorial(") > 1
-
-        self.assertFalse(
-            recursive_calls,
-            "'factorial' soll iterativ implementiert sein. Es wurden rekursive Aufrufe gefunden."
-        )
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-```
-def fibonacci(n):
-    if n == 0:
-        return 0
-    elif n == 1:
-        return 1
-
-    a, b = 0, 1
-    for _ in range(2, n + 1):
-        a, b = b, a + b 
-    return b
-```
-
----
-
-Here is the Python test suite based on the provided code:
-
-```
-import unittest
-import inspect
-
-class TestFactorialFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'fibonacci' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'fibonacci' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_fibonacci_of_zero(self):
-        """
-        Prüft, ob 'fibonacci' die Fibonacci-Zahl von 0 korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(0), 0, "'fibonacci' soll für 0 den Wert 
-0 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_fibonacci_of_one(self):
-        """
-        Prüft, ob 'fibonacci' die Fibonacci-Zahl von 1 korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(1), 1, "'fibonacci' soll für 1 den Wert 
-1 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_fibonacci_of_small_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' die Fibonacci-Zahl einer kleinen positiven 
-Zahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(5), 5, "'fibonacci' soll für 5 den Wert 
-5 zurückgeben. Überprüfe die rekursive Implementierung.")
-
-    def test_fibonacci_of_large_positive_integer(self):
-        """
-        Prüft, ob 'fibonacci' die Fibonacci-Zahl einer großen positiven 
-Zahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(10), 55, "'fibonacci' soll für 10 den 
-Wert 55 zurückgeben. Überprüfe die Skalierbarkeit.")
-
-    def test_invalid_negative_integer(self):
-        """
-        Prüft, ob 'fibonacci' bei negativen Zahlen einen Fehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'fibonacci' soll bei 
-negativen Eingaben einen Fehler werfen. Überprüfe die Validierung."):
-            fibonacci(-1)
-
-    def test_invalid_type(self):
-        """
-        Prüft, ob 'fibonacci' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'fibonacci' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe die Typenvalidierung."):
-            fibonacci("5")
-
-    def test_iterative_implementation(self):
-        """
-        Prüft, ob 'fibonacci' iterativ implementiert ist, indem die Anzahl 
-der Aufrufe im Quellcode überprüft wird.
-        """
-        import inspect
-        source_code = inspect.getsource(fibonacci)
-
-        recursive_calls = source_code.count("fibonacci(") > 1
-
-        self.assertFalse(
-            recursive_calls,
-            "'fibonacci' soll iterativ implementiert sein. Es wurden 
-rekursive Aufrufe gefunden."
-        )
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ✅
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ✅
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/8**
-
----
-
-```
-import unittest
-
-class TestFactorialFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'factorial' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'factorial' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_fibonacci_of_zero(self):
-        """
-        Prüft, ob 'factorial' die Fibonacci-Sequenz von 0 korrekt 
-berechnet.
-        """
-        self.assertEqual(fibonacci(0), 0, "'factorial' soll für 0 den Wert 
-0 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_fibonacci_of_one(self):
-        """
-        Prüft, ob 'factorial' die Fibonacci-Sequenz von 1 korrekt 
-berechnet.
-        """
-        self.assertEqual(fibonacci(1), 1, "'factorial' soll für 1 den Wert 
-1 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_fibonacci_of_small_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fibonacci-Sequenz einer kleinen 
-positiven Zahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(5), 5, "'factorial' soll für 5 den Wert 
-5 zurückgeben. Überprüfe die Rekursionslogik.")
-
-    def test_fibonacci_of_large_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fibonacci-Sequenz einer großen positiven 
-Zahl korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(10), 55, "'factorial' soll für 10 den 
-Wert 55 zurückgeben. Überprüfe die Skalierbarkeit.")
-
-    def test_invalid_negative_integer(self):
-        """
-        Prüft, ob 'factorial' bei negativen Zahlen einen Fehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'factorial' soll bei 
-negativen Eingaben einen Fehler werfen. Überprüfe die Validierung."):
-            fibonacci(-1)
-
-    def test_invalid_type(self):
-        """
-        Prüft, ob 'factorial' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'factorial' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe die Typenvalidierung."):
-            fibonacci("5")
-
-    def test_iterative_implementation(self):
-        """
-        Prüft, ob 'factorial' iterativ implementiert ist, indem die Anzahl 
-der Aufrufe im Quellcode überprüft wird.
-        """
-        import inspect
-        source_code = inspect.getsource(fibonacci)
-
-        recursive_calls = source_code.count("fibonacci(") > 1
-
-        self.assertFalse(
-            recursive_calls,
-            "'factorial' soll iterativ implementiert sein. Es wurden 
-rekursive Aufrufe gefunden."
-        )
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ✅
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ✅
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/8**
-
----
-
-```
-import unittest
-
-class TestFactorialFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'factorial' existiert.
-        """
-        self.assertTrue(callable(fibonacci), "'factorial' soll existieren. 
-Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_factorial_of_zero(self):
-        """
-        Prüft, ob 'factorial' die Fakultät von 0 korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(0), 0, "'factorial' soll für 0 den Wert 
-0 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_factorial_of_one(self):
-        """
-        Prüft, ob 'factorial' die Fakultät von 1 korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(1), 1, "'factorial' soll für 1 den Wert 
-1 zurückgeben. Überprüfe die Basisfälle.")
-
-    def test_factorial_of_small_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fakultät einer kleinen positiven Zahl 
-korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(5), 5, "'factorial' soll für 5 den Wert 
-5 zurückgeben. Überprüfe die Iteration.")
-
-    def test_factorial_of_large_positive_integer(self):
-        """
-        Prüft, ob 'factorial' die Fakultät einer großen positiven Zahl 
-korrekt berechnet.
-        """
-        self.assertEqual(fibonacci(10), 55, "'factorial' soll für 10 den 
-Wert 55 zurückgeben. Überprüfe die Skalierbarkeit.")
-
-    def test_invalid_negative_integer(self):
-        """
-        Prüft, ob 'factorial' bei negativen Zahlen einen Fehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'factorial' soll bei 
-negativen Eingaben einen Fehler werfen. Überprüfe die Validierung."):
-            fibonacci(-1)
-
-    def test_invalid_type(self):
-        """
-        Prüft, ob 'factorial' bei String-Eingangen einen Typfehler 
-auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'factorial' soll für 
-String-Eingaben einen Typfehler werfen. Überprüfe die Typenvalidierung."):
-            fibonacci("5")
-
-    def test_iterative_implementation(self):
-        """
-        Prüft, ob 'factorial' iterativ implementiert ist, indem die Anzahl 
-der Aufrufe im Quellcode überprüft wird.
-        """
-        import inspect
-        source_code = inspect.getsource(fibonacci)
-
-        recursive_calls = source_code.count("fibonacci(") > 1
-
-        self.assertFalse(
-            recursive_calls,
-            "'factorial' soll iterativ implementiert sein. Es wurden 
-rekursive Aufrufe gefunden."
-        )
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "fibonacci" Funkton existiert ✅
-2. Gibt für eine '0' Eingabe das Ergebnis: 0 aus ✅
-3. Gibt für die '1' Eingabe das Ergebnis: 1 aus ✅
-4. Berechnet die n'te Stelle der Fibonacci Reihe korrekt ✅
-5. Berechnet die n'te Stelle für große Zahlen korrekt ✅
-6. Prüft ob die Implementierung iterativ umgesetzt wurde ✅
-7. Wirft einen Typfehler für Eingaben die nicht integer Zahlen sind ✅
-8. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/8**
-
-***Total: 24/24***
-
----
diff --git a/appx/feedback_nuterbefragung.md b/appx/feedback_nuterbefragung.md
deleted file mode 100644
index 93938bb866287328a5c1e2c635567ec4269ac3be..0000000000000000000000000000000000000000
--- a/appx/feedback_nuterbefragung.md
+++ /dev/null
@@ -1,235 +0,0 @@
-### **Feedback Nutzerbefragung**
-
-## **Auswertungstabelle**
-
-### Aufgabe 1-3 Ergebnisüberischt
-
-| **Aufgabe**        | **Antwort** | **richtige Antworten** | **Prozent** |
-|---------------------|-------------------|-----------------------|-------------|
-| Aufgabe 1           | 4                 | 8/10                    | 80.00%      |
-| Aufgabe 2           | 2                 | 8/10                    | 80.00%      |
-| Aufgabe 3           | 6/3               | 9/10                    | 90.00%      |
-
-## Ergebnisse der Umfrage zur Feedback-Qualität
-
-| **Frage**                                     | **Proband 1** | **Proband 2** | **Proband 3** | **Proband 4** | **Proband 5** | **Proband 6** | **Proband 7** | **Proband 8** | **Proband 9** | **Proband 10** | **Durchschnitt** |
-|-----------------------------------------------|---------------|---------------|---------------|---------------|---------------|---------------|---------------|---------------|---------------|----------------|------------------|
-| Wie hilfreich war Feedback zu „add(0, 1)“?    | 1             | 1             | 2             | 3             | 1             | 1             | 1             | 4             | 1             | 1              | 1,7              | 
-| Wie verständlich war Feedback zu „add(-2, 3)“?| 1             | 1             | 2             | 2             | 3             | 1             | 1             | 3             | 2             | 1              | 1,8              | 
-| Wie hilfreich war Feedback zu Kommazahlen?    | 2             | 2             | 2             | 3             | 3             | 2             | 1             | 3             | 4             | 1              | 2,3              |
-
----
-
-## **Einleitungstext**
-Testfeedback Fragebogen
-Mit diesem Fragebogen möchte ich herausfinden, wie hilfreich KI-generiertes Feedback zu Programmiertests in der ArTEMiS-Lernumgebung für Programmieranfänger*innen ist. Programmiertests sind kurze Codeabschnitte, die überprüfen, ob ein anderer Code wie erwartet funktioniert.
-Falls dir Begriffe wie „Codeabschnitt“ und „Programmiertest“ noch kompliziert vorkommen, keine Sorge – diese Umfrage ist genau für dich gemacht!
-Bitte beantworte die Fragen so genau und ehrlich wie möglich.
-Vielen Dank für deine Teilnahme!
-
---- 
-
-## **Aufgaben der Teilnehmenden**
-Deine Aufgabe
-Stell dir vor, du sollst einen Programmiercode schreiben, der zwei Zahlen addiert (Additionsfunktion). Damit deine Lösung als korrekt gilt, müssen alle Programmiertests bestanden werden. Du erhältst jedoch Fehlermeldungen, diese sind in den folgenden Fragen aufgeführt. Kannst du herausfinden, warum dein Code nicht funktioniert?
-
----
-
-## **Hinweis-Einschub**
-Feedback-Nachrichten
-Werfen wir nun einen genaueren Blick auf die Feedback-Nachrichten, die jeweils am Anfang der Fehlermeldung nach ‘AssertionError:’ in den ersten drei Fragen zu finden sind.
-(VORSICHT: Die Fragen unterscheiden sich, bitte lies sie dir genau durch!)
-
----
-
-## **Frage 1**
-
-**Warum funktioniert dein Code nicht?**
-
-AssertionError: 0 != 1 : ‚add‘ soll mit ‚0‘ addieren können. Stelle sicher, dass der Code ‚0‘ korrekt behandelt. Hast du getestet, ob ‚0‘ als Teil der Addition funktioniert?
-
-self = < behavior.behavior_test.TestAddFunctionBehavior testMethod=test_add_zero_and_integer >
-
-def test_add_zero_and_integer(self):
-"""
-Prüft, ob ‚add‘ die Zahl ‚0‘ korrekt addiert.
-"""
-> self.assertEqual(
-add(0, 1), 1,
-"’add‘ soll mit ‚0‘ addieren können. Stelle sicher, dass der Code ‚0‘ korrekt behandelt. Hast du getestet, ob ‚0‘ als Teil der Addition funktioniert?“
-)
-
-Antwortoptionen: 
-1 Weil sehr große Zahlen falsch addiert wurden.
-2 Weil eine positive und eine negative Zahl falsch addiert wurden.
-3 Weil zwei positive Zahlen falsch addiert wurden.
-4 Weil 0 nicht richtig addiert wurde.
-5 Weil nur eine Zahl, statt zwei Zahlen eingegeben wurde.
-6 Keine der Optionen ist richtig.
-7 Ich weiß es nicht.
-
-Proband 1: 4
-Proband 2: 4
-Proband 3: 7
-Proband 4: 7
-Proband 5: 4
-Proband 6: 4
-Proband 7: 4
-Proband 8: 4
-Proband 9: 4
-Proband 10: 4
-
----
-
-## **Frage 2**
-
-**Warum funktioniert dein Code nicht?**
-
-
-AssertionError: 3 != 1 : ‚add‘ soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden. Wie behandelst du Vorzeichen in deinem Code?
-
-self = < behavior.behavior_test.TestAddFunctionBehaviortestMethod=test_add_positive_and_negative_integer >
-
-def test_add_positive_and_negative_integer(self):
-"""
-Prüft, ob ‚add‘ eine positive und eine negative Zahl korrekt addiert.
-"""
-> self.assertEqual(
-add(-2, 3), 1,
-"’add‘ soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden. Wie behandelst du Vorzeichen in deinem Code?“
-)
-
-Antwortoptionen: 
-1 Weil sehr große Zahlen falsch addiert wurden.
-2 Weil eine positive und eine negative Zahl falsch addiert wurden.
-3 Weil zwei positive Zahlen falsch addiert wurden.
-4 Weil 0 nicht richtig addiert wurde.
-5 Weil nur eine Zahl, statt zwei Zahlen eingegeben wurde.
-6 Keine der Optionen ist richtig.
-7 Ich weiß es nicht.
-
-Proband 1: 2
-Proband 2: 2
-Proband 3: 1
-Proband 4: 7
-Proband 5: 2
-Proband 6: 2
-Proband 7: 2
-Proband 8: 2
-Proband 9: 2
-Proband 10: 2
-
----
-
-## **Frage 3**
-
-**Warum funktioniert dein Code nicht?**
-
-AssertionError: 4.5 != 4.0 : ‚add‘ soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden. Wird das Ergebnis auf die richtige Genauigkeit geprüft?
-
-self = < behavior.behavior_test.TestAddFunctionBehavior testMethod=test_add_two_floats >
-
-def test_add_two_floats(self):
-"""
-Prüft, ob ‚add‘ zwei Kommazahlen korrekt addiert.
-"""
-> self.assertEqual(
-add(1.5, 2.5), 4.0,
-"’add‘ soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden. Wird das Ergebnis auf die richtige Genauigkeit geprüft?“
-)
-
-Antwortoptionen: 
-1 Weil sehr große Zahlen falsch addiert wurden.
-2 Weil eine positive und eine negative Zahl falsch addiert wurden.
-3 Weil zwei positive Zahlen falsch addiert wurden.
-4 Weil 0 nicht richtig addiert wurde.
-5 Weil nur eine Zahl, statt zwei Zahlen eingegeben wurde.
-6 Keine der Optionen ist richtig.
-7 Ich weiß es nicht.
-
-Proband 1: 6
-Proband 2: 6
-Proband 3: 3
-Proband 4: 7
-Proband 5: 3
-Proband 6: 3
-Proband 7: 6
-Proband 8: 6
-Proband 9: 6
-Proband 10: 6
-
----
-
-## **Frage 4**
-
-**Wie hilfreich fandest du diesen Satz, um bei der ersten Frage herauszufinden, warum dein Code nicht funktioniert?**
-
-‚add‘ soll mit ‚0‘ addieren können. Stelle sicher, dass der Code ‚0‘ korrekt behandelt. Hast du getestet, ob ‚0‘ als Teil der Addition funktioniert?
-
-Antwortoptionen:
-1 Sehr hilfreich
-2 Hilfreich
-3 Neutral
-4 eher nicht hilfreich
-5 Gar nicht Hilfreich
-
-Proband 1: 1
-Proband 2: 1
-Proband 3: 2
-Proband 4: 3
-Proband 5: 1
-Proband 6: 1
-Proband 7: 1
-Proband 8: 4
-Proband 9: 1
-Proband 10: 1
-
----
-
-## **Frage 5**
-
-**Wie verständlich findest du diesen Satz aus Frage zwei?**
-
-‚add‘ soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden. Wie behandelst du Vorzeichen in deinem Code?
-
-1 Sehr verständlich
-2 verständlich
-3 Neutral
-4 eher nicht verständlich
-5 Gar nicht verständlich
-
-Proband 1: 1
-Proband 2: 1
-Proband 3: 2
-Proband 4: 2
-Proband 5: 3
-Proband 6: 1
-Proband 7: 1
-Proband 8: 3
-Proband 9: 2
-Proband 10: 1
-
----
-
-## **Frage 6**
-
-**Wie hilfreich würdest du diesen Satz aus Frage drei finden, um an einer Lösung der Aufgabe weiterzuarbeiten?**
-
-‚add‘ soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden. Wird das Ergebnis auf die richtige Genauigkeit geprüft?
-
-1 Sehr hilfreich
-2 Hilfreich
-3 Neutral
-4 eher nicht hilfreich
-5 Gar nicht Hilfreich
-
-Proband 1: 2
-Proband 2: 2
-Proband 3: 2
-Proband 4: 3
-Proband 5: 3
-Proband 6: 2
-Proband 7: 1
-Proband 8: 3
-Proband 9: 4
-Proband 10: 1
diff --git a/appx/modelfileuntersuchung.md b/appx/modelfileuntersuchung.md
deleted file mode 100644
index 57c04fa5be74eccd34dd2fefc90b96dfb94d68ee..0000000000000000000000000000000000000000
--- a/appx/modelfileuntersuchung.md
+++ /dev/null
@@ -1,1527 +0,0 @@
-# **Modelfileuntersuchung**
-
-In der folgenden Analyse wird der Einfluss eines System Prompts sowie verschiedener Laufzeit Parameter hinsichtlich ihres Einflusses auf die Leistungsfähigkeit bei der Testgenerierung untersucht. Jeder Test durchlauf besteht aus drei Iterationen der gleichen Prompteingabe.
-
-Die Ergebnisse der Modellausgabe werden anschließend mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Abschließend werden die Ergebnisse in **Auswertungstabellen** zusammengefasst und gegenübergestellt. Diese befinden sich der Übersichtlichkeit halber am Anfang des Dokuments.
-
----
-
-## **Auswertungstabelle**
-
-| **Modellparameter**                            | **Iteration 1** | **Iteration 2** | **Iteration 3** | **Total** | **Prozent** |
-|---------------------------------------|-----------------|-----------------|-----------------|-----------|-------------|
-| **Standard-Parameter**                   | 8/10            | 9/10            | 6/10            | 23/30     | 76,67%      |
-| **System-Prompt mit Standard-Parametern** | 5/10            | 5/10            | 5/10            | 15/30     | 50,00%      |
-| **Konservative-Parameter**               | 1/10            | 1/10            | 5/10            | 7/30     | 23,33%      |
-| **Kreative-Parameter**                   | 7/10            | 8/10            | 6/10            | 21/30     | 70,00%      |
-| **Sehr Kreative-Parameter**                   | 5/10            | 1/10            | 1/10            | 7/30     | 23,33%      |
-
----
-
-### **Standard-Prompt ohne Modelfileanpassungen**
-
----
-
-You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-### Requirements ###
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
-### Example ###
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-```
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_with_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit positiven Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll positive Ganzzahlen korrekt berechnen. Überprüfe, ob der Code für einfache Mittelwerte funktioniert.")
-
-    def test_calculate_mean_with_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit negativen Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll negative Ganzzahlen korrekt berechnen. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_calculate_mean_with_mixed_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit gemischten positiven und negativen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, 0, 1]), 0.0, "'calculate_mean' soll gemischte positive und negative Zahlen korrekt berechnen. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_with_floats(self):
-        """
-        Prüft, ob 'calculate_mean' mit Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt berechnet werden.")
-
-    def test_calculate_mean_with_zero(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([0]), 0.0, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_with_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt berechnet.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll für leere Listen 'None' zurückgeben. Überprüfe, ob die Eingaben korrekt validiert werden.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-    def test_invalid_type_non_numeric(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht numerischen Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für nicht numerische Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, "a", 2])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als ungültig erkennen. Überprüfe die Rückgabewerte.")
-
-    def test_calculate_mean_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' für Listen mit einem Element korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1]), 1, "'calculate_mean' soll eine Liste mit einem Element addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei positive Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, -2]), -1.5, "'calculate_mean' soll zwei negative Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-2, 3]), 0.5, "'calculate_mean' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_two_floats(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_float_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 1]), 1.25, "'calculate_mean' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_zero_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([0, 1]), 0.5, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt mit None zurückgibt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste mit None zurückgeben. Überprüfe den Code für leerer Listen.")
-
-    def test_calculate_mean_single_value(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([5]), 5, "'calculate_mean' soll eine Liste mit einem Wert korrekt zurückgeben. Überprüfe den Code für Listen mit einzelnen Werten.")
-
-    def test_calculate_mean_two_values(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Zahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei Zahlen korrekt addieren und den Mittelwert berechnen.")
-
-    def test_calculate_mean_mixed_type(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit verschiedenen Typen korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1, 2.5, -3]), -0.3333333333333333, "'calculate_mean' soll Listen mit verschiedenen Typen korrekt verarbeiten.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/10**
-
-***Total: 23/30***
-
----
-
-## **Mit System Prompt**
-
-**System Prompt**
-
----
-
-You are a Python test generation tool. **Your primary task is to generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
----
-
-**User Prompt**
-
----
-
-Generate a comprehensive Python test suite for the provided code, ensuring it aligns with the structure and style of the example code. 
-
-### Example ###
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-```
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste auf 'None' setzen. Überprüfe, ob der Code für leere Listen funktioniert.")
-
-    def test_calculate_mean_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' eine Einzelausgabe korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1]), 1, "'calculate_mean' soll eine Liste mit einem Element auf denselben Wert setzen. Überprüfe, ob der Code für einfache Listen funktioniert.")
-
-    def test_calculate_mean_multiple_elements(self):
-        """
-        Prüft, ob 'calculate_mean' mehrere Ausgaben korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll eine Liste von Zahlen summiert und den Mittelwert berechnen. Überprüfe, ob der Code für Listen mit mehreren Elementen funktioniert.")
-
-    def test_calculate_mean_mixed_types(self):
-        """
-        Prüft, ob 'calculate_mean' gemischte Datentypen korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1, 2.5]), 1.75, "'calculate_mean' soll gemischte Datentypen wie Ganzzahlen und Kommazahlen korrekt addieren. Überprüfe, ob der Code für Listen mit verschiedenen Typen funktioniert.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean("a")
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(None)
-
-    def test_calculate_mean_invalid_type_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei Listen-Eingaben mit falschen Elementen einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für Listen-Eingaben mit falschen Elementen einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, "a", 2])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/10**
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als 'None' zurückgeben. Überprüfe, ob der Code für keine Eingaben funktioniert.")
-
-    def test_calculate_mean_single_value(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer einzigen Eingabe den Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([1]), 1.0, "'calculate_mean' soll eine einzige Eingabe korrekt berechnen. Überprüfe, ob der Code einfache Zahlen korrekt behandelt.")
-
-    def test_calculate_mean_multiple_values(self):
-        """
-        Prüft, ob 'calculate_mean' bei mehreren Eingaben den Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll mehrere Werte korrekt berechnen. Überprüfe, ob der Code für einfache Listen korrekt funktioniert.")
-
-    def test_calculate_mean_mixed_int_float(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer Liste aus Mischung von ganzen und Fließkommazahlen den Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([1, 2.5]), 1.75, "'calculate_mean' soll eine Mischung aus ganzen und Fließkommazahlen korrekt berechnen. Überprüfe, ob der Code für Listen mit verschiedenen Typen korrekt funktioniert.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean("a")
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandles.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll für eine leere Liste None zurückgeben. Überprüfe, ob der Code für den Fall einer leeren Eingabe funktioniert.")
-
-    def test_calculate_mean_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' eine Einzelelement-Liste korrekt behandles.
-        """
-        self.assertEqual(calculate_mean([5]), 5.0, "'calculate_mean' soll die Element-Zahl als Durchschnitt zurückgeben. Überprüfe, ob der Code für einfache Listen funktioniert.")
-
-    def test_calculate_mean_multiple_elements(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mehrerer Elemente korrekt behandles.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll die Durchschnittsberechnung für Listen mit mehreren Elementen durchführen.")
-
-    def test_calculate_mean_mixed_float_int(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von Float und Integer korrekt behandles.
-        """
-        self.assertAlmostEqual(calculate_mean([1.5, 2.0, 3]), 2.1666666666666665, places=5, msg="'calculate_mean' soll Mixed-Float-Integer-Liste korrekt durchführen.")
-
-    def test_calculate_mean_invalid_type(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht-ganzen Typen einen Fehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für unzulässige Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean("a")
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/10**
-
-**Total: 15/30**
-
----
-
-### **Konservative Parameter mit Standad-Prompt**
-
-## **Modelfile**
-
-```
-FROM llama3
-
-PARAMETER temperature 0.5
-PARAMETER num_ctx 4096
-PARAMETER repeat_penalty 1.3
-PARAMETER num_predict -2
-PARAMETER top_k 30
-PARAMETER top_p 0.85
-```
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'calculate mean' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'calculate mean' two negative integers korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, -2]), -1.5, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'calculate mean' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-2, 3]), 0.5, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'calculate mean' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'calculate mean' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2]), 1.75, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'calculate mean' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'calculate mean' sehr große Zahlen umgehen kann.
-        """
-        self.assertEqual(calculate_mean([float('inf'), 1]), float('nan'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingangen einen Typfehler werfen. Überprüfe, ob die Einggaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate mean' bei None-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für None-Eingangen einen Typfehler werfen. Überprüfe, ob die Einggaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ❌
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkung:
-- Alle Tests fälschlicherweise auf 'add' (Beispiel Funktion) bezogen
-
-**Punkte: 1/10**
-
----
-
-```
-import unittest
-from your_module import add, calculate_mean  # Import the functions to be 
-tested
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzenalzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzenalzahlen umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' sehr große Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingangen einen Typfehler werfen. Überprüfe, ob die Eingänge korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für None-Eingänge einen Typfehler werfen. Überprüfe, ob die Eingänge korrekt validiert werden."): add(1, None)
-
-    def test_calculate_mean(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von Zahlen richtig berechnet.
-        """
-        self.assertEqual(calculate_mean([0]), 0.0)
-        
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ❌
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkung:
-- Alle Tests fälschlicherweise auf 'add' (Beispiel Funktion) bezogen
-
-**Punkte: 1/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll für leerer Listen den Wert `None` zurückgeben. Überprüfe die Korrektheit des Rückgabewerts.")
-
-    def test_calculate_mean_single_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem ganzen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1]), 1.0, "'calculate_mean' soll Listen mit einer Zahl richtig berechnen.")
-
-    def test_calculate_mean_single_float(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Fließzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5]), 1.5, "'calculate_mean' soll Listen mit einer Kommazahl richtig berechnen.")
-
-    def test_calculate_mean_multiple_integers(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mehrerer ganzen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll Listen mit mehreren Zahlen richtig berechnen.")
-
-    def test_calculate_mean_multiple_floats(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mehrerer Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2]), 1.75, "'calculate_mean' soll Listen mit mehreren Kommazahlen richtig berechnen.")
-
-    def test_calculate_mean_mixed_integers_and_floats(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von ganzen Zahlen und Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2]), 1.75, "'calculate_mean' soll Listen mit Mischung aus Ganzzahl und Kommazahl richtig berechnen.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingangen einen Typfehler werfen. Überprüfe die Eingabegültigkeit"): calculate_mean("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für `None`-Eingangen einen Typfehler werfen. Überprüfe die Eingabegültigkeit"): calculate_mean(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/10**
-
-***Total: 7/30***
-
----
-
-### **Kreative Parameter mit Standad-Prompt**
-
-## **Modelfile**
-
-```
-FROM llama3
-
-PARAMETER temperature 0.9
-PARAMETER num_ctx 4096
-PARAMETER repeat_penalty 1.1
-PARAMETER num_predict -2
-PARAMETER top_k 50
-PARAMETER top_p 0.95
-```
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll eine leere Liste als 'None' zurückgeben. Überprüfe, ob der Code für leere Listen funktioniert.")
-
-    def test_calculate_mean_single_element_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Element korrekt behandeldd.
-        """
-        self.assertEqual(calculate_mean([5]), 5, "'calculate_mean' soll eine Liste mit einem Element korrekt berechnen. Überprüfe, ob das Ergebnis stimmt.")
-
-    def test_calculate_mean_multiple_elements_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit mehreren Elementen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll eine Liste mit mehreren Elementen korrekt berechnen. Überprüfe, ob das Ergebnis stimmt.")
-
-    def test_calculate_mean_mixed_types_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit verschiedenen Typen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3.5]), 2.1666666666666665, "'calculate_mean' soll eine Liste mit verschiedenen Typen korrekt berechnen. Überprüfe, ob das Ergebnis stimmt.")
-
-    def test_calculate_mean_non_number_types_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht-numerischen Elementen einen Fehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für keine Liste von nicht-numerischen Elementen berechnen können. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, 'a', None])
-
-    def test_calculate_mean_negative_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' negative Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll negative Zahlen korrekt berechnen. Überprüfe, ob das Ergebnis stimmt.")
-
-    def test_calculate_mean_large_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' große Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([10**1000, 10**999]), (10**999.5), "'calculate_mean' soll auch sehr große Zahlen berechnen können. Überprüfe, ob das Ergebnis stimmt.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' einen leeren Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als Null zurückgeben. Überprüfe, ob die Funktion ein passendes Ergebnis für leere Listen returniert.")
-
-    def test_calculate_mean_single_element_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Element korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1]), 1.0, "'calculate_mean' soll die Durchschnittsberechnung für Listen mit einem Element durchführen.")
-
-    def test_calculate_mean_positive_integer_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von positiven Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll positive Ganzzahlen addieren können.")
-
-    def test_calculate_mean_negative_integer_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von negativen Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, -2]), -1.5, "'calculate_mean' soll negative Ganzzahlen addieren können.")
-
-    def test_calculate_mean_positive_and_negative_integer_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von positiven und negativen Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, 2]), 0.5, "'calculate_mean' soll positive und negative Ganzzahlen addieren können.")
-
-    def test_calculate_mean_float_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.0]), 1.75, "'calculate_mean' soll mit Kommazahlen umgehen können.")
-
-    def test_calculate_mean_mixed_type_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von verschiedenen Typen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2.5]), 1.75, "'calculate_mean' soll verschiedene Typen wie Ganzzahlen und Kommazahlen addieren können.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als Ergebnis von 'None' ergeben. Überprüfe, ob die Funktion für leere Listen korrekt reagiert.")
-
-    def test_calculate_mean_list_with_integers(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit ganzen Zahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll die Summe einer Liste von Ganzzahlen ergeben. Überprüfe, ob die Funktion für einfache Summen funktioniert.")
-
-    def test_calculate_mean_list_with_floats(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit Fließkommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.0, 3.0]), 2.1666666666666667, "'calculate_mean' soll die Summe einer Liste von Kommazahlen ergeben. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_calculate_mean_list_with_mixed_types(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit gemischt Typen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2.5, 3]), 2.0, "'calculate_mean' soll die Summe einer Liste von verschiedenen Typen ergeben. Überprüfe, ob die Funktion verschiedene Typen korrekt verarbeitet.")
-
-    def test_calculate_mean_list_with_zero(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit dem Wert '0' korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, -3]), 0.33333333333333337, "'calculate_mean' soll die Summe einer Liste von Zahlen ergeben. Überprüfe, ob der Code für den Wert '0' korrekt reagiert.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingangen einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/10**
-
-***Total: 21/39***
-
----
-
-### ** Sehr kreative Parameter mit Standad-Prompt**
-
-## **Modelfile**
-
-```
-FROM llama3
-
-PARAMETER temperature 1.1
-PARAMETER num_ctx 4096
-PARAMETER repeat_penalty 1.0
-PARAMETER num_predict -2
-PARAMETER top_k 60
-PARAMETER top_p 0.96
-```
-
----
-
-Here is the Python test suite for the provided code:
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' einen leeren Listen korrekt behandelt.
-        """
-        self.assertIs(calculate_mean([]), None, "'calculate_mean' soll für eine leere Liste None zurückgeben.")
-
-    def test_calculate_mean_single_number(self):
-        """
-        Prüft, ob 'calculate_mean' eine einzige Zahl korrekt behanellt.
-        """
-        self.assertEqual(calculate_mean([5]), 5, "'calculate_mean' soll für eine einzige Zahl die Zahl zurückgeben.")
-
-    def test_calculate_mean_integer_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3, 4]), 2.5, "'calculate_mean' soll eine Liste von Ganzzahlen addieren können.")
-
-    def test_calculate_mean_float_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste von Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, 3.5, 4.5]), 3.0, "'calculate_mean' soll mit Kommazahlen umgehen können.")
-
-    def test_calculate_mean_mixed_integer_float_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine Mischung von Ganzzahlen und Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3, 4.5]), 2.5, "'calculate_mean' soll eine Mischung von Ganzzahlen und Kommazahlen addieren können.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a"])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/10**
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(1000000, 1), 1000001, "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-    def test_invalid_type_none_again(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(None, 1)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ❌
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkung:
-- Alle Tests fälschlicherweise auf 'add' (Beispiel Funktion) bezogen
-
-**Punkte: 1/10**
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(10**100, 10**100), 10**100, "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-    def test_add_too_few_arguments(self):
-        """
-        Prüft, ob 'add' zu wenig Argumente akzeptiert.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll zu wenig Argumente akzeptieren. Überprüfe, ob die Funktion die richtigen Anzahl von Eingaben annimmt."): add()
-
-    def test_add_too_many_arguments(self):
-        """
-        Prüft, ob 'add' zu viele Argumente akzeptiert.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll zu viele Argumente akzeptieren. Überprüfe, ob die Funktion die richtigen Anzahl von Eingaben annimmt."): add(1, 2, 3)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ❌
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkung:
-- Alle Tests fälschlicherweise auf 'add' (Beispiel Funktion) bezogen
-
-**Punkte: 1/10**
-
-***Total: 7/30***
-
----
diff --git a/appx/modellauswertung.md b/appx/modellauswertung.md
deleted file mode 100644
index 147bf9315670a57e3c98aa68b293e6cabbcd223f..0000000000000000000000000000000000000000
--- a/appx/modellauswertung.md
+++ /dev/null
@@ -1,3288 +0,0 @@
-# **Modellauswertung**
-
-In der folgenden Analyse werden die Modelle **Llama3** (lokal installiert mit Ollama) und **GPT-4o** hinsichtlich ihrer Leistungsfähigkeit bei der Testgenerierung untersucht. Jedes Modell wird mit fünf repräsentativen **Testfällen** getestet, wobei jeder Testfall in drei Durchläufen evaluiert wird. Als Eingabe dient der zuvor in der **Promptuntersuchung** entwickelte **Kombinationsprompt**, der mit den jeweiligen Testfällen ergänzt und den Modellen übergeben wird.
-
-Die Ergebnisse der Modelle werden anschließend mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Abschließend werden die Ergebnisse in **Auswertungstabellen** zusammengefasst und gegenübergestellt. Diese befinden sich der Übersichtlichkeit halber am Anfang des Dokuments.
-
----
-
-## **Auswertungstabellen**
-
-### Test 1: Subtraktion
-| **Iteration** | **Llama3**        | **GPT-4o**       |
-|---------------|-------------------|------------------|
-| 1             | 10/10     | 10/10    |
-| 2             | 10/10     | 10/10    |
-| 3             | 1/10      | 10/10    |
-| **Total:**    | **21/30 = 70%**  | **30/30 = 100%** |
-
-### Test 2: Multioperation
-| **Iteration** | **Llama3**        | **GPT-4o**       |
-|---------------|-------------------|------------------|
-| 1             | 13/30    | 24/30    |
-| 2             | 29/30    | 18/30    |
-| 3             | 21/30    | 24/30    |
-| **Total:**    | **63/90 = 70%**  | **66/90 = 73,33%** |
-
-### Test 3: Quadratwurzel
-| **Iteration** | **Llama3**        | **GPT-4o**       |
-|---------------|-------------------|------------------|
-| 1             | 0/9    | 9/9      |
-| 2             | 6/9    | 9/9      |
-| 3             | 6/9    | 9/9      |
-| **Total:**    | **12/27 = 44,44%** | **27/27 = 100%** |
-
-### Test 4: Mittelwertberechnung
-| **Iteration** | **Llama3**        | **GPT-4o**       |
-|---------------|-------------------|------------------|
-| 1             | 8/10      | 7/10      |
-| 2             | 9/10      | 8/10      |
-| 3             | 6/10      | 8/10      |
-| **Total:**    | **23/30 = 76,67%** | **23/30 = 76,67%** |
-
-### Test 5: Schaltjahrprüfung
-| **Iteration** | **Llama3**        | **GPT-4o**       |
-|---------------|-------------------|------------------|
-| 1             | 6/6    | 6/6       |
-| 2             | 5/6    | 6/6       |
-| 3             | 5/6    | 6/6       |
-| **Total:**    | **16/18 = 88,89%** | **18/18 = 100%** |
-
-### Gesamtbewertung
-| **Modell**    | **Gesamtpunkte (Summe)** | **Durchschnitt (Prozent)** | **Durchschnitt der Einzelprozente** |
-|---------------|--------------------------|----------------------------|-------------------------------------|
-| **Llama3**    | 135/195         | 69,23%                     | 70,38%                             |
-| **GPT-4o**    | 164/195         | 84,10%                     | 90,00%                             |
-
----
-
-## **Kombinationsprompt**
-
-You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-### Requirements ###
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
-### Example ###
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-{code}
-
----
-
-## **Testfälle**
-
-### **Test 1:**
-
-```
-def sub(a, b):
-    return a - b
-```
-
-### **Test 2:**
-
-```
-def sub(a, b):
-    return a - b
-
-def mul(a, b):
-    return a * b
-
-def div(a, b):
-    return a / b
-```
-
-### **Test 3:**
-
-```
-import math
-
-class MathOperations:
-
-    def square_root(a):
-        return math.sqrt(a)
-```
-
-### **Test 4:**
-
-```
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
-### **Test 5:**
-
-```
-def is_leap_year(year: int):
-    if year % 4 == 0:
-        if year % 100 == 0:
-            if year % 400 == 0:
-                return True
-            else:
-                return False
-        else:
-            return True
-    else:
-        return False
-```
-
----
-
-## **Llama3**
-
-### **Test 1:**
-
----
-
-Here is the complete Python test suite for the provided code:
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(4, 1), 3, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe, ob der Code für einfache Differenzen funktioniert.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-2, -3), 1, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3, -2), 5, "'sub' soll eine negative und eine positive Zahl subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(4.5, 2.0), 2.5, "'sub' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3.5, 1), 2.5, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(1, 0), 1, "'sub' soll mit '0' subtrahieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(float('inf'), float('-inf')), 0, "'sub' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 10/10**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(4, 2), 2, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe, ob der Code für einfache Differenzen funktioniert.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-2, -3), 1, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3, -2), 5, "'sub' soll eine positive und eine negative Zahl subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3.5, 2.0), 1.5, "'sub' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3.0, 1), 2.0, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(1, 0), 1, "'sub' soll mit '0' subtrahieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(float('inf'), 1), float('inf'), "'sub' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-'''
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 10/10**
-
----
-
-Here is the complete Python test suite for the provided code:
-
-```
-import unittest
-from your_module import add  # Assuming the function 'add' is defined in this module
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlern addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ❌
-2. Subtrahiert zwei positive Ganzzahlen ❌
-3. Subtrahiert zwei negative Ganzzahlen ❌
-4. Subtrahiert eine positive und eine negative Ganzzahlen ❌
-5. Subtrahiert zwei Gleitkommazahlen ❌
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Subtrahiert eine Ganzzahl mit 0 ❌
-8. Subtrahiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen:
-- Alle Testfälle wurden auf 'add' Bezogen, daher alle Fehlerhaft
-
-**Punkte: 1/10**
-
-***Total: 21/30***
-
-### **Test 2:**
-
----
-
-Here is the Python test suite for the provided code:
-
-```
-import unittest
-from your_module import add, sub, mul, div  # replace 'your_module' with the actual name of the module containing the functions
-
-class TestFunctions(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktionen 'add', 'sub', 'mul', und 'div' existieren.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_function(self):
-        """
-        Prüft, ob 'add' korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll einfache Additionen durchführen. Überprüfe, ob die Funktionalität für Ganzzahlen und Kommazahlen umgeht.")
-        self.assertEqual(add(-1, -2), -3, "'add' soll negative Zahlen addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-        self.assertEqual(add(0, 1), 1, "'add' soll die Zahl '0' korrekt addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_function(self):
-        """
-        Prüft, ob 'sub' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(1, 2), -1, "'sub' soll einfache Subtraktionen durchführen. Überprüfe, ob die Funktionalität für Ganzzahlen und Kommazahlen umgeht.")
-        self.assertEqual(sub(-1, -2), 1, "'sub' soll negative Zahlen subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_mul_function(self):
-        """
-        Prüft, ob 'mul' korrekt multipliziert.
-        """
-        self.assertEqual(mul(1, 2), 2, "'mul' soll einfache Multiplikationen durchführen. Überprüfe, ob die Funktionalität für Ganzzahlen und Kommazahlen umgeht.")
-        self.assertEqual(mul(-1, -2), 2, "'mul' soll negative Zahlen multiplizieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_div_function(self):
-        """
-        Prüft, ob 'div' korrekt dividiert.
-        """
-        self.assertEqual(div(1, 2), 0.5, "'div' soll einfache Divisionen durchführen. Überprüfe, ob die Funktionalität für Ganzzahlen und Kommazahlen umgeht.")
-        with self.assertRaises(ZeroDivisionError, msg="'div' soll bei nullteilen einen Fehler werfen. Überprüfe, ob der Code für solche Fälle bereit ist."): div(1, 0)
-        self.assertEqual(div(-1, -2), 0.5, "'div' soll negative Zahlen dividieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob die Funktionen bei String-Eingaben einen Typfehler auslösen.
-        """
-        with self.assertRaises(TypeError, msg="Die Funktionen sollen für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-        with self.assertRaises(TypeError, msg="Die Funktionen sollen für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob die Funktionen bei 'None'-Eingaben einen Typfehler auslösen.
-        """
-        with self.assertRaises(TypeError, msg="Die Funktionen sollen für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-        with self.assertRaises(TypeError, msg="Die Funktionen sollen für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ❌
-5. Subtrahiert zwei Gleitkommazahlen ❌
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Subtrahiert eine Ganzzahl mit 0 ❌
-8. Subtrahiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ❌
-5. Multipliziert zwei Gleitkommazahlen ❌
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Multipliziert eine Ganzzahl mit 0 ❌
-8. Multipliziert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ✅
-4. Dividiert eine positive und eine negative Ganzzahlen ❌
-5. Dividiert zwei Gleitkommazahlen ❌
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Wirft einen Error für Division mit 0❌
-8. Dividiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen:
-- 'add' Testfälle wurden fälschlicherweise mit implementiert. 
-
-**Punkte: 13/30**
-
----
-
-Here is the Python test suite for the provided code:
-
-```
-import unittest
-
-class TestOperations(unittest.TestCase):
-
-    def test_sub_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2, 1), 1, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe, ob der Code für einfache Differenzen funktioniert.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-2, -1), -1, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(3, -2), 5, "'sub' soll eine negative und eine positive Zahl subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2.5, 1.0), 1.5, "'sub' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2.5, 1), 1.5, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2, 1), 1, "'sub' soll mit '0' subtrahieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(float('inf'), 1), float('inf'), "'sub' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_sub_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub("a", 1)
-
-    def test_sub_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub(1, None)
-
-    def test_mul_function_exists(self):
-        """
-        Prüft, ob die Funktion 'mul' existiert.
-        """
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mul_two_positive_integers(self):
-        """
-        Prüft, ob 'mul' zwei positive Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(2, 3), 6, "'mul' soll zwei positive Ganzzahlen multiplizieren können. Überprüfe, ob der Code für einfache Multiplikationen funktioniert.")
-
-    def test_mul_two_negative_integers(self):
-        """
-        Prüft, ob 'mul' zwei negative Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(-2, -3), 6, "'mul' soll zwei negative Ganzzahlen multiplizieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_mul_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'mul' eine positive und eine negative Zahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(-2, 3), -6, "'mul' soll eine negative und eine positive Zahl multiplizieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_mul_two_floats(self):
-        """
-        Prüft, ob 'mul' zwei Kommazahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(2.5, 1.0), 2.5, "'mul' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt multipliziert werden.")
-
-    def test_mul_float_and_integer(self):
-        """
-        Prüft, ob 'mul' eine Kommazahl und eine Ganzzahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(2.5, 1), 2.5, "'mul' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_mul_zero_and_integer(self):
-        """
-        Prüft, ob 'mul' die Zahl '0' korrekt multipliziert.
-        """
-        self.assertEqual(mul(2, 0), 0, "'mul' soll mit '0' multiplizieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_mul_large_number(self):
-        """
-        Prüft, ob 'mul' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(mul(float('inf'), 1), float('inf'), "'mul' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_mul_invalid_type_string(self):
-        """
-        Prüft, ob 'mul' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): mul("a", 1)
-
-    def test_mul_invalid_type_none(self):
-        """
-        Prüft, ob 'mul' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): mul(1, None)
-
-    def test_div_function_exists(self):
-        """
-        Prüft, ob die Funktion 'div' existiert.
-        """
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_div_two_positive_integers(self):
-        """
-        Prüft, ob 'div' zwei positive Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(6, 3), 2, "'div' soll zwei positive Ganzzahlen dividieren können. Überprüfe, ob der Code für einfache Divisionen funktioniert.")
-
-    def test_div_two_negative_integers(self):
-        """
-        Prüft, ob 'div' zwei negative Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(-6, -3), 2, "'div' soll zwei negative Ganzzahlen dividieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_div_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'div' eine positive und eine negative Zahl korrekt dividiert.
-        """
-        self.assertEqual(div(-6, 3), -2, "'div' soll eine negative und eine positive Zahl dividieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_div_two_floats(self):
-        """
-        Prüft, ob 'div' zwei Kommazahlen korrekt dividiert.
-        """
-        self.assertEqual(div(2.5, 1.0), 2.5, "'div' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt dividieren werden.")
-
-    def test_div_float_and_integer(self):
-        """
-        Prüft, ob 'div' eine Kommazahl und eine Ganzzahl korrekt dividiert.
-        """
-        self.assertEqual(div(2.5, 1), 2.5, "'div' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_div_zero_and_integer(self):
-        """
-        Prüft, ob 'div' die Zahl '0' korrekt dividiert.
-        """
-        self.assertRaises(ZeroDivisionError, lambda: div(2, 0))
-
-    def test_div_large_number(self):
-        """
-        Prüft, ob 'div' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(div(float('inf'), 1), float('inf'), "'div' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_div_invalid_type_string(self):
-        """
-        Prüft, ob 'div' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): div("a", 1)
-
-    def test_div_invalid_type_none(self):
-        """
-        Prüft, ob 'div' bei 'None'-Eingangen einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): div(1, None)
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ❌
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ✅
-5. Multipliziert zwei Gleitkommazahlen ✅
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Multipliziert eine Ganzzahl mit 0 ✅
-8. Multipliziert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ✅
-4. Dividiert eine positive und eine negative Ganzzahlen ✅
-5. Dividiert zwei Gleitkommazahlen ✅
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Wirft einen Error für Division mit 0 ✅
-8. Dividiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen:
-- Feedback für 'div' durch 0 fehlt
-- Schließendes Markup (```) wurde zur Darstellung ergänzt, ist aber nicht Teil der Modellausgabe
-
-**Punkte: 29/30**
-
----
-
-Here is the Python test suite for the provided code:
-
-```
-import unittest
-from your_module import add, sub, mul, div
-
-class TestMathFunctions(unittest.TestCase):
-
-    def test_sub_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2, 1), 1, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe, ob der Code für einfache Differenzen funktioniert.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-2, -1), 1, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2, -1), 3, "'sub' soll eine positive und eine negative Zahl subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(2.5, 1.5), 1.0, "'sub' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(1.5, 1), 0.5, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(1, 0), 1, "'sub' soll mit '0' subtrahieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(float('inf'), -1), float('inf'), "'sub' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_sub_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub("a", 1)
-
-    def test_sub_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): sub(1, None)
-
-    # Test for mul and div functions
-    def test_mul_function_exists(self):
-        """
-        Prüft, ob die Funktion 'mul' existiert.
-        """
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_div_function_exists(self):
-        """
-        Prüft, ob die Funktion 'div' existiert.
-        """
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    # Test for mul function
-    def test_mul_two_positive_integers(self):
-        """
-        Prüft, ob 'mul' zwei positive Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(2, 3), 6, "'mul' soll zwei positive Ganzzahlen multiplizieren können. Überprüfe, ob der Code für einfache Produkte funktioniert.")
-
-    def test_mul_two_negative_integers(self):
-        """
-        Prüft, ob 'mul' zwei negative Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(-2, -3), 6, "'mul' soll zwei negative Ganzzahlen multiplizieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_mul_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'mul' eine positive und eine negative Zahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(2, -3), -6, "'mul' soll eine positive und eine negative Zahl multiplizieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_mul_two_floats(self):
-        """
-        Prüft, ob 'mul' zwei Kommazahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(2.5, 3.0), 7.5, "'mul' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_mul_float_and_integer(self):
-        """
-        Prüft, ob 'mul' eine Kommazahl und eine Ganzzahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(1.5, 2), 3.0, "'mul' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    # Test for div function
-    def test_div_two_positive_integers(self):
-        """
-        Prüft, ob 'div' zwei positive Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(6, 2), 3, "'div' soll zwei positive Ganzzahlen dividieren können. Überprüfe, ob der Code für einfache Quotienten funktioniert.")
-
-    def test_div_two_negative_integers(self):
-        """
-        Prüft, ob 'div' zwei negative Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(-6, -2), 3, "'div' soll zwei negative Ganzzahlen dividieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_div_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'div' eine positive und eine negative Zahl korrekt dividiert.
-        """
-        self.assertEqual(div(6, -2), -3, "'div' soll eine positive und eine negative Zahl dividieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_div_invalid_type_string(self):
-        """
-        Prüft, ob 'div' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): div("a", 1)
-
-    def test_div_invalid_type_none(self):
-        """
-        Prüft, ob 'div' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): div(1, None)
-
-if __name__ == '__main__':
-    test_suite = unittest.TestSuite([test_subtract, test_multiply, test_divide])
-    runner = unittest.TextTestRunner()
-    runner.run(test_suite)
-```
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ❌
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ✅
-5. Multipliziert zwei Gleitkommazahlen ✅
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Multipliziert eine Ganzzahl mit 0 ❌
-8. Multipliziert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ✅
-4. Dividiert eine positive und eine negative Ganzzahlen ✅
-5. Dividiert zwei Gleitkommazahlen ❌
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Wirft einen Error für Division mit 0 ❌
-8. Dividiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste)✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen:
-- Schließendes Markup (```) wurde zur Darstellung ergänzt, ist aber nicht Teil der Modellausgabe
-
-**Punkte: 21/30**
-
-***Total: 63/90***
-
-### **Test 3:**
-
----
-
-```
-import unittest
-from your_module import add, MathOperations  # Import the code under test
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
----
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ❌
-2. "squere_root" Funkton existiert ❌
-4. Wirft einen ValueError für eine negativen Ganzzahl ❌
-4. Berechnet die Qadratwurzel einer negativen Ganzzahl ❌
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ❌
-6. Berechnet die Qadratwurzel von 0 ❌
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ❌
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen:
-- Test fäschlicherweise für 'add' implementiert
-
-**Punkte: 0/9**
-
----
-
-Here is the Python test suite for the provided code:
-```
-import unittest
-from your_module import MathOperations, add  # Replace 'your_module' with the actual module name
-
-class TestMathOperations(unittest.TestCase):
-
-    def test_square_root_function_exists(self):
-        """
-        Prüft, ob die Funktion 'square_root' existiert.
-        """
-        self.assertTrue(callable(MathOperations.square_root), "'square_root' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_square_root_positive_integer(self):
-        """
-        Prüft, ob 'square_root' eine positive Ganzzahl korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(4), 2.0, places=5, msg="'square_root' soll eine positive Ganzzahl berechnen können. Überprüfe, ob der Code für einfache Wurzeln funktioniert.")
-
-    def test_square_root_zero(self):
-        """
-        Prüft, ob 'square_root' die Zahl '0' korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(0), 0.0, places=5, msg="'square_root' soll mit '0' berechnen können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_square_root_negative_integer(self):
-        """
-        Prüft, ob 'square_root' eine negative Ganzzahl korrekt berechnet.
-        """
-        with self.assertRaises(ValueError, msg="'square_root' soll für negative Zahlen einen Fehler werfen. Überprüfe, ob die Wurzelberechnung korrekt implementiert ist."): MathOperations.square_root(-1)
-
-    def test_square_root_non_numeric_input(self):
-        """
-        Prüft, ob 'square_root' bei nicht-numeric-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll für nicht-numeric-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): MathOperations.square_root("a")
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ❌
-2. "squere_root" Funkton existiert ✅
-3. Berechnet die Qadratwurzel einer positiven Ganzzahl ✅
-4. Wirft einen ValueError für eine negativen Ganzzahl ✅
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ❌
-6. Berechnet die Qadratwurzel von 0 ✅
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ❌
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/9**
-
----
-
-Here is the comprehensive Python test suite for the provided code:
-
-```python
-import unittest
-import math
-
-class TestMathOperations(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'square_root' existiert.
-        """
-        self.assertTrue(callable(MathOperations.square_root), "'square_root' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_square_root_positive_integer(self):
-        """
-        Prüft, ob 'square_root' eine positive Ganzzahl korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(4), 2, msg="'square_root' soll eine positive Ganzzahl berechnen können. Überprüfe, ob die Funktion für einfache Wurzeln funktioniert.")
-
-    def test_square_root_negative_integer(self):
-        """
-        Prüft, ob 'square_root' eine negative Ganzzahl korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(-4), -2, msg="'square_root' soll eine negative Ganzzahl berechnen können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_square_root_zero(self):
-        """
-        Prüft, ob 'square_root' die Zahl '0' korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(0), 0, msg="'square_root' soll mit der Zahl '0' umgehen können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_square_root_large_number(self):
-        """
-        Prüft, ob 'square_root' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(float('inf')), math.inf, msg="'square_root' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_square_root_invalid_type_string(self):
-        """
-        Prüft, ob 'square_root' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): MathOperations.square_root("a")
-
-    def test_square_root_invalid_type_none(self):
-        """
-        Prüft, ob 'square_root' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): MathOperations.square_root(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ❌
-2. "squere_root" Funkton existiert ✅
-3. Berechnet die Qadratwurzel einer positiven Ganzzahl ✅
-4. Wirft einen ValueError für eine negativen Ganzzahl ❌
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ❌
-6. Berechnet die Qadratwurzel von 0 ✅
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ✅
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen:
-- def test_square_root_negative_integer(self): ist fehlerhaft implementiert
-
-**Punkte: 6/9**
-
-***Total: 12/27***
-
-### **Test 4:**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_with_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit positiven Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll positive Ganzzahlen korrekt berechnen. Überprüfe, ob der Code für einfache Mittelwerte funktioniert.")
-
-    def test_calculate_mean_with_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit negativen Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll negative Ganzzahlen korrekt berechnen. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_calculate_mean_with_mixed_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit gemischten positiven und negativen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, 0, 1]), 0.0, "'calculate_mean' soll gemischte positive und negative Zahlen korrekt berechnen. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_with_floats(self):
-        """
-        Prüft, ob 'calculate_mean' mit Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt berechnet werden.")
-
-    def test_calculate_mean_with_zero(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([0]), 0.0, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_with_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt berechnet.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll für leere Listen 'None' zurückgeben. Überprüfe, ob die Eingaben korrekt validiert werden.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-    def test_invalid_type_non_numeric(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht numerischen Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für nicht numerische Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, "a", 2])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als ungültig erkennen. Überprüfe die Rückgabewerte.")
-
-    def test_calculate_mean_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' für Listen mit einem Element korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1]), 1, "'calculate_mean' soll eine Liste mit einem Element addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei positive Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, -2]), -1.5, "'calculate_mean' soll zwei negative Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-2, 3]), 0.5, "'calculate_mean' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_two_floats(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_float_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 1]), 1.25, "'calculate_mean' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_zero_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([0, 1]), 0.5, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt mit None zurückgibt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste mit None zurückgeben. Überprüfe den Code für leerer Listen.")
-
-    def test_calculate_mean_single_value(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([5]), 5, "'calculate_mean' soll eine Liste mit einem Wert korrekt zurückgeben. Überprüfe den Code für Listen mit einzelnen Werten.")
-
-    def test_calculate_mean_two_values(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Zahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei Zahlen korrekt addieren und den Mittelwert berechnen.")
-
-    def test_calculate_mean_mixed_type(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit verschiedenen Typen korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1, 2.5, -3]), -0.3333333333333333, "'calculate_mean' soll Listen mit verschiedenen Typen korrekt verarbeiten.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/10**
-
-***Total: 23/30***
-
-### **Test 5:**
-
----
-
-```
-import unittest
-
-class TestIsLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_leap_years(self):
-        """
-        Prüft, ob 'is_leap_year' Jahre korrekt als Schaltjahre erkennt.
-        """
-        self.assertTrue(is_leap_year(2000), "'is_leap_year' soll Jahre als Schaltjahr erkennen können. Überprüfe die Logik für Schaltjahre.")
-        self.assertTrue(is_leap_year(1992), "'is_leap_year' soll Jahre als Schaltjahr erkennen können. Überprüfe die Logik für Schaltjahre.")
-        self.assertFalse(is_leap_year(1900), "'is_leap_year' soll Jahre als Schaltjahr erkennen können. Überprüfe die Logik für Schaltjahre.")
-
-    def test_non_leap_years(self):
-        """
-        Prüft, ob 'is_leap_year' Jahre korrekt als Nicht-Schaltjahre erkennt.
-        """
-        self.assertFalse(is_leap_year(1999), "'is_leap_year' soll Jahre als Nicht-Schaltjahr erkennen können. Überprüfe die Logik für nicht-Schaltjahre.")
-        self.assertFalse(is_leap_year(1700), "'is_leap_year' soll Jahre als Nicht-Schaltjahr erkennen können. Überprüfe die Logik für nicht-Schaltjahre.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'is_leap_year' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'is_leap_year' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ✅
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ✅
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen:
-- 1900 Test ist zwar richtig als Falsch gekennzeichnet, aber der Kommentar und die Zuordnung ist falsch. 
-
-**Punkte: 6/6**
-
----
-
-```
-import unittest
-
-class TestLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_leap_year_2020(self):
-        """
-        Prüft, ob 2020 ein Schaltjahr ist.
-        """
-        self.assertTrue(is_leap_year(2020), "2020 sollte als Schaltjahr erkannt werden. Überprüfe die Implementierung der 'is_leap_year'-Funktion.")
-
-    def test_non_leap_year_2019(self):
-        """
-        Prüft, ob 2019 kein Schaltjahr ist.
-        """
-        self.assertFalse(is_leap_year(2019), "2019 sollte nicht als Schaltjahr erkannt werden. Überprüfe die Implementierung der 'is_leap_year'-Funktion.")
-
-    def test_leap_year_2000(self):
-        """
-        Prüft, ob 2000 ein Schaltjahr ist.
-        """
-        self.assertTrue(is_leap_year(2000), "2000 sollte als Schaltjahr erkannt werden. Überprüfe die Implementierung der 'is_leap_year'-Funktion.")
-
-    def test_non_leap_year_2017(self):
-        """
-        Prüft, ob 2017 kein Schaltjahr ist.
-        """
-        self.assertFalse(is_leap_year(2017), "2017 sollte nicht als Schaltjahr erkannt werden. Überprüfe die Implementierung der 'is_leap_year'-Funktion.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'is_leap_year' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year("a")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'is_leap_year' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year(None)
-
-    def test_invalid_type_integer_zero(self):
-        """
-        Prüft, ob 'is_leap_year' bei Integer-Eingabe 0 einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für Integer-Eingabe 0 einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year(0)
-
-    def test_invalid_type_integer_negative(self):
-        """
-        Prüft, ob 'is_leap_year' bei negativer Integer-Eingabe einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für negative Integer-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year(-1)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ✅
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ❌
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/6**
-
----
-
-```
-import unittest
-
-class TestIsLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_is_leap_year_divisible_by_4(self):
-        """
-        Prüft, ob 'is_leap_year' eine Schaltjahreszahl korrekt erkennt.
-        """
-        self.assertTrue(is_leap_year(2020), "'is_leap_year' soll Schaltjahreszahlen korrekt erkennen. Überprüfe, ob die Funktionalität für einfache Fälle funktioniert.")
-
-    def test_is_leap_year_divisible_by_100(self):
-        """
-        Prüft, ob 'is_leap_year' eine durch 100 teilbare Jahrzahl korrekt erkennt.
-        """
-        self.assertFalse(is_leap_year(1900), "'is_leap_year' soll keine durch 100 teilbaren Jahrzahlen als Schaltjahre erkennen. Überprüfe, ob die Funktionalität für spezielle Fälle funktioniert.")
-
-    def test_is_leap_year_divisible_by_400(self):
-        """
-        Prüft, ob 'is_leap_year' eine durch 400 teilbare Jahrzahl korrekt erkennt.
-        """
-        self.assertTrue(is_leap_year(2000), "'is_leap_year' soll durch 400 teilbare Jahrzahlen als Schaltjahre erkennen. Überprüfe, ob die Funktionalität für spezielle Fälle funktioniert.")
-
-    def test_is_leap_year_invalid_type(self):
-        """
-        Prüft, ob 'is_leap_year' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year("a")
-
-    def test_is_leap_year_invalid_type_none(self):
-        """
-        Prüft, ob 'is_leap_year' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): is_leap_year(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ❌
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ✅
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 5/6**
-
-***Total: 16/18***
-
----
-
-## **GPT-4o**
-
-### **Test 1:**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe, ob die Berechnung korrekt ist.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, -3), -2, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl subtrahieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 3.2), 2.3, "'sub' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt subtrahiert werden.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 3), 2.5, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 0), 5, "'sub' soll mit '0' korrekt subtrahieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(1e18, 1), 1e18 - 1, "'sub' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_sub_resulting_in_negative(self):
-        """
-        Prüft, ob 'sub' korrekt subtrahiert, wenn das Ergebnis negativ ist.
-        """
-        self.assertEqual(sub(3, 5), -2, "'sub' soll korrekt subtrahieren, auch wenn das Ergebnis negativ ist. Überprüfe die Berechnung.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            sub(None, 1)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 10/10**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen korrekt subtrahieren. Überprüfe die Implementierung.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, -3), -2, "'sub' soll zwei negative Ganzzahlen korrekt subtrahieren. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl korrekt subtrahieren. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_sub_negative_and_positive_integer(self):
-        """
-        Prüft, ob 'sub' eine negative und eine positive Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, 3), -8, "'sub' soll eine negative und eine positive Zahl korrekt subtrahieren können. Überprüfe die Implementierung.")
-
-    def test_sub_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 3.2), 2.3, "'sub' soll zwei Kommazahlen korrekt subtrahieren. Überprüfe die Präzision der Fließkommazahlen.")
-
-    def test_sub_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 3), 2.5, "'sub' soll eine Kommazahl und eine Ganzzahl korrekt subtrahieren. Achte auf die Typenkompatibilität.")
-
-    def test_sub_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 0), 5, "'sub' soll korrekt mit '0' umgehen können. Überprüfe, ob der Code '0' korrekt behandelt.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(1e15, 1e10), 999990000000000.0, "'sub' soll mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): 
-            sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): 
-            sub(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 10/10**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_subtract_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen korrekt subtrahieren. Überprüfe die Berechnungslogik.")
-
-    def test_subtract_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, -3), -2, "'sub' soll zwei negative Ganzzahlen korrekt subtrahieren. Achte darauf, dass die Vorzeichen korrekt berücksichtigt werden.")
-
-    def test_subtract_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl korrekt subtrahieren. Überprüfe die Behandlung der Vorzeichen.")
-
-    def test_subtract_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 3.2), 2.3, "'sub' soll zwei Kommazahlen korrekt subtrahieren. Achte auf die Genauigkeit der Berechnung.")
-
-    def test_subtract_float_and_integer(self):
-        """
-        Prüft, ob 'sub' eine Kommazahl und eine Ganzzahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5.5, 2), 3.5, "'sub' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_subtract_zero_and_integer(self):
-        """
-        Prüft, ob 'sub' die Zahl '0' korrekt behandelt.
-        """
-        self.assertEqual(sub(5, 0), 5, "'sub' soll mit der Zahl '0' korrekt umgehen können. Vergewissere dich, dass keine Sonderfälle ausgelassen werden.")
-
-    def test_subtract_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(1e10, 1e9), 9e9, "'sub' soll auch mit sehr großen Zahlen umgehen können. Überprüfe die Stabilität bei großen Werten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): 
-            sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): 
-            sub(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 10/10**
-
-***Total: 30/30***
-
-### **Test 2:**
-
----
-
-```
-import unittest
-
-class TestMathFunctions(unittest.TestCase):
-
-    def test_sub_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_typical_inputs(self):
-        """
-        Prüft, ob 'sub' typische Werte korrekt verarbeitet.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen korrekt subtrahieren.")
-        self.assertEqual(sub(-3, -5), 2, "'sub' soll zwei negative Ganzzahlen korrekt subtrahieren.")
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl korrekt subtrahieren.")
-
-    def test_sub_edge_cases(self):
-        """
-        Prüft, ob 'sub' Randfälle korrekt behandelt.
-        """
-        self.assertEqual(sub(0, 0), 0, "'sub' soll '0 - 0' korrekt berechnen.")
-        self.assertEqual(sub(1.5, 0.5), 1.0, "'sub' soll Kommazahlen korrekt subtrahieren.")
-
-    def test_sub_type_errors(self):
-        """
-        Prüft, ob 'sub' Typfehler korrekt auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll bei String-Eingaben einen Typfehler auslösen."):
-            sub("a", 1)
-        with self.assertRaises(TypeError, msg="'sub' soll bei 'None'-Eingaben einen Typfehler auslösen."):
-            sub(None, 1)
-
-    def test_mul_exists(self):
-        """
-        Prüft, ob die Funktion 'mul' existiert.
-        """
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mul_typical_inputs(self):
-        """
-        Prüft, ob 'mul' typische Werte korrekt verarbeitet.
-        """
-        self.assertEqual(mul(2, 3), 6, "'mul' soll zwei positive Ganzzahlen korrekt multiplizieren.")
-        self.assertEqual(mul(-2, -3), 6, "'mul' soll zwei negative Ganzzahlen korrekt multiplizieren.")
-        self.assertEqual(mul(2, -3), -6, "'mul' soll eine positive und eine negative Zahl korrekt multiplizieren.")
-
-    def test_mul_edge_cases(self):
-        """
-        Prüft, ob 'mul' Randfälle korrekt behandelt.
-        """
-        self.assertEqual(mul(0, 100), 0, "'mul' soll '0' korrekt behandeln.")
-        self.assertEqual(mul(1.5, 2), 3.0, "'mul' soll mit Kommazahlen korrekt multiplizieren.")
-
-    def test_mul_type_errors(self):
-        """
-        Prüft, ob 'mul' Typfehler korrekt auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll bei String-Eingaben einen Typfehler auslösen."):
-            mul("a", 1)
-        with self.assertRaises(TypeError, msg="'mul' soll bei 'None'-Eingaben einen Typfehler auslösen."):
-            mul(None, 1)
-
-    def test_div_exists(self):
-        """
-        Prüft, ob die Funktion 'div' existiert.
-        """
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_div_typical_inputs(self):
-        """
-        Prüft, ob 'div' typische Werte korrekt verarbeitet.
-        """
-        self.assertEqual(div(6, 3), 2.0, "'div' soll zwei positive Ganzzahlen korrekt dividieren.")
-        self.assertEqual(div(-6, -3), 2.0, "'div' soll zwei negative Ganzzahlen korrekt dividieren.")
-        self.assertEqual(div(6, -3), -2.0, "'div' soll eine positive und eine negative Zahl korrekt dividieren.")
-
-    def test_div_edge_cases(self):
-        """
-        Prüft, ob 'div' Randfälle korrekt behandelt.
-        """
-        self.assertEqual(div(0, 1), 0.0, "'div' soll 0 korrekt behandeln, wenn es durch eine Zahl dividiert wird.")
-        with self.assertRaises(ZeroDivisionError, msg="'div' soll bei Division durch 0 einen Fehler auslösen."):
-            div(1, 0)
-
-    def test_div_type_errors(self):
-        """
-        Prüft, ob 'div' Typfehler korrekt auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll bei String-Eingaben einen Typfehler auslösen."):
-            div("a", 1)
-        with self.assertRaises(TypeError, msg="'div' soll bei 'None'-Eingaben einen Typfehler auslösen."):
-            div(None, 1)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ✅
-5. Multipliziert zwei Gleitkommazahlen ✅
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Multipliziert eine Ganzzahl mit 0 ✅
-8. Multipliziert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ✅
-4. Dividiert eine positive und eine negative Ganzzahlen ✅
-5. Dividiert zwei Gleitkommazahlen ✅
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Wirft einen Error für Division mit 0 ✅
-8. Dividiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 24/30**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_sub_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen korrekt subtrahieren. Überprüfe die Berechnung.")
-
-    def test_sub_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, -3), -2, "'sub' soll zwei negative Ganzzahlen korrekt subtrahieren. Achte auf die Behandlung der Vorzeichen.")
-
-    def test_sub_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl korrekt subtrahieren. Überprüfe die Addition bei negativen Zahlen.")
-
-    def test_sub_large_number(self):
-        """
-        Prüft, ob 'sub' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(sub(float('inf'), 1), float('inf'), "'sub' soll auch mit großen Zahlen umgehen können. Überprüfe, ob keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Verifiziere die Eingabevalidierung."):
-            sub("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'sub' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            sub(1, None)
-
-class TestMulFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'mul' existiert.
-        """
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mul_two_positive_integers(self):
-        """
-        Prüft, ob 'mul' zwei positive Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(2, 3), 6, "'mul' soll zwei positive Ganzzahlen multiplizieren. Überprüfe die Berechnung.")
-
-    def test_mul_negative_and_positive_integer(self):
-        """
-        Prüft, ob 'mul' eine negative und eine positive Zahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(-2, 3), -6, "'mul' soll eine negative und eine positive Zahl multiplizieren können. Achte auf die Vorzeichen.")
-
-    def test_mul_with_zero(self):
-        """
-        Prüft, ob 'mul' mit der Zahl '0' korrekt multipliziert.
-        """
-        self.assertEqual(mul(0, 5), 0, "'mul' soll '0' korrekt behandeln. Überprüfe, ob der Rückgabewert korrekt ist.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'mul' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll für String-Eingaben einen Typfehler werfen. Verifiziere die Eingabevalidierung."):
-            mul("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'mul' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            mul(1, None)
-
-class TestDivFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'div' existiert.
-        """
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_div_two_positive_integers(self):
-        """
-        Prüft, ob 'div' zwei positive Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(6, 3), 2, "'div' soll zwei positive Ganzzahlen korrekt dividieren. Überprüfe die Berechnung.")
-
-    def test_div_by_zero(self):
-        """
-        Prüft, ob 'div' eine Division durch Null korrekt behandelt.
-        """
-        with self.assertRaises(ZeroDivisionError, msg="'div' soll bei Division durch Null einen Fehler werfen. Überprüfe die Ausnahmebehandlung."):
-            div(5, 0)
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'div' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für String-Eingaben einen Typfehler werfen. Verifiziere die Eingabevalidierung."):
-            div("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'div' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'div' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            div(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ❌
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ❌
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Subtrahiert eine Ganzzahl mit 0 ❌
-8. Subtrahiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ✅
-5. Multipliziert zwei Gleitkommazahlen ❌
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Multipliziert eine Ganzzahl mit 0 ✅
-8. Multipliziert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ❌
-4. Dividiert eine positive und eine negative Ganzzahlen ❌
-5. Dividiert zwei Gleitkommazahlen ❌
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Wirft einen Error für Division mit 0 ✅
-8. Dividiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 18/30**
-
----
-
-```
-import unittest
-
-class TestSubFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'sub' existiert.
-        """
-        self.assertTrue(callable(sub), "'sub' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_subtract_two_positive_integers(self):
-        """
-        Prüft, ob 'sub' zwei positive Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, 3), 2, "'sub' soll zwei positive Ganzzahlen subtrahieren können. Überprüfe die Berechnung.")
-
-    def test_subtract_two_negative_integers(self):
-        """
-        Prüft, ob 'sub' zwei negative Ganzzahlen korrekt subtrahiert.
-        """
-        self.assertEqual(sub(-5, -3), -2, "'sub' soll zwei negative Ganzzahlen subtrahieren können. Vergewissere dich, dass Vorzeichen korrekt behandelt werden.")
-
-    def test_subtract_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'sub' eine positive und eine negative Zahl korrekt subtrahiert.
-        """
-        self.assertEqual(sub(5, -3), 8, "'sub' soll eine positive und eine negative Zahl subtrahieren können. Achte auf korrekte Vorzeichenbehandlung.")
-
-    def test_subtract_two_floats(self):
-        """
-        Prüft, ob 'sub' zwei Kommazahlen korrekt subtrahiert.
-        """
-        self.assertAlmostEqual(sub(5.5, 2.5), 3.0, places=2, msg="'sub' soll mit Kommazahlen umgehen können. Überprüfe die Fließkommaarithmetik.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'sub' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'sub' soll für String-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            sub("a", 1)
-
-class TestMulFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'mul' existiert.
-        """
-        self.assertTrue(callable(mul), "'mul' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_multiply_two_positive_integers(self):
-        """
-        Prüft, ob 'mul' zwei positive Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(3, 4), 12, "'mul' soll zwei positive Ganzzahlen multiplizieren können. Überprüfe die Berechnung.")
-
-    def test_multiply_two_negative_integers(self):
-        """
-        Prüft, ob 'mul' zwei negative Ganzzahlen korrekt multipliziert.
-        """
-        self.assertEqual(mul(-3, -4), 12, "'mul' soll zwei negative Ganzzahlen multiplizieren können. Achte auf korrektes Vorzeichenhandling.")
-
-    def test_multiply_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'mul' eine positive und eine negative Zahl korrekt multipliziert.
-        """
-        self.assertEqual(mul(3, -4), -12, "'mul' soll eine positive und eine negative Zahl multiplizieren können. Überprüfe die Vorzeichen.")
-
-    def test_multiply_with_zero(self):
-        """
-        Prüft, ob 'mul' mit der Zahl '0' korrekt umgeht.
-        """
-        self.assertEqual(mul(0, 5), 0, "'mul' soll mit '0' multiplizieren können. Überprüfe die Nullbehandlung.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'mul' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'mul' soll für String-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            mul("a", 1)
-
-class TestDivFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'div' existiert.
-        """
-        self.assertTrue(callable(div), "'div' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_divide_two_positive_integers(self):
-        """
-        Prüft, ob 'div' zwei positive Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(8, 4), 2, "'div' soll zwei positive Ganzzahlen dividieren können. Überprüfe die Berechnung.")
-
-    def test_divide_two_negative_integers(self):
-        """
-        Prüft, ob 'div' zwei negative Ganzzahlen korrekt dividiert.
-        """
-        self.assertEqual(div(-8, -4), 2, "'div' soll zwei negative Ganzzahlen dividieren können. Achte auf korrektes Vorzeichenhandling.")
-
-    def test_divide_positive_and_negative
-```
-
----
-
-### **Auswertung**
-1. "sub" Funkton existiert ✅
-2. Subtrahiert zwei positive Ganzzahlen ✅
-3. Subtrahiert zwei negative Ganzzahlen ✅
-4. Subtrahiert eine positive und eine negative Ganzzahlen ✅
-5. Subtrahiert zwei Gleitkommazahlen ✅
-6. Subtrahiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Subtrahiert eine Ganzzahl mit 0 ✅
-8. Subtrahiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "mul" Funkton existiert ✅
-2. Multipliziert zwei positive Ganzzahlen ✅
-3. Multipliziert zwei negative Ganzzahlen ✅
-4. Multipliziert eine positive und eine negative Ganzzahlen ✅
-5. Multipliziert zwei Gleitkommazahlen ❌
-6. Multipliziert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Multipliziert eine Ganzzahl mit 0 ✅
-8. Multipliziert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-1. "div" Funkton existiert ✅
-2. Dividiert zwei positive Ganzzahlen ✅
-3. Dividiert zwei negative Ganzzahlen ✅
-4. Dividiert eine positive und eine negative Ganzzahlen ❌
-5. Dividiert zwei Gleitkommazahlen ❌
-6. Dividiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Wirft einen Error für Division mit 0 ❌
-8. Dividiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 24/30**
-
-***Total: 66/90***
-
-### **Test 3:**
-
----
-
-```
-import unittest
-import math
-
-class TestMathOperations(unittest.TestCase):
-
-    def test_class_exists(self):
-        """
-        Prüft, ob die Klasse 'MathOperations' existiert.
-        """
-        self.assertTrue('MathOperations' in globals(), "'MathOperations' soll existieren. Vergewissere dich, dass die Klasse definiert ist.")
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'square_root' existiert.
-        """
-        self.assertTrue(hasattr(MathOperations, 'square_root') and callable(getattr(MathOperations, 'square_root')),
-                        "'square_root' soll existieren. Vergewissere dich, dass die Funktion in der Klasse 'MathOperations' definiert ist.")
-
-    def test_square_root_positive_integer(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer positiven Ganzzahl korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(4), 2, 
-                         "'square_root' soll die Quadratwurzel einer positiven Ganzzahl berechnen. Überprüfe den Algorithmus.")
-
-    def test_square_root_positive_float(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer positiven Kommazahl korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(2.25), 1.5, 
-                         "'square_root' soll die Quadratwurzel einer positiven Kommazahl berechnen. Vergewissere dich, dass Fließkommazahlen korrekt verarbeitet werden.")
-
-    def test_square_root_zero(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel von 0 korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(0), 0, 
-                         "'square_root' soll die Quadratwurzel von 0 berechnen. Stelle sicher, dass der Code für diesen Randfall funktioniert.")
-
-    def test_square_root_negative_number(self):
-        """
-        Prüft, ob 'square_root' bei negativen Zahlen einen Fehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'square_root' soll bei negativen Zahlen einen Fehler werfen. Überprüfe die Eingabevalidierung."):
-            MathOperations.square_root(-1)
-
-    def test_square_root_large_number(self):
-        """
-        Prüft, ob 'square_root' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(1e10), 1e5, 
-                               "'square_root' soll auch mit sehr großen Zahlen umgehen können. Überprüfe die Genauigkeit für große Eingabewerte.")
-
-    def test_square_root_non_numeric_input(self):
-        """
-        Prüft, ob 'square_root' bei nicht-numerischen Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll für nicht-numerische Eingaben einen Typfehler werfen. Stelle sicher, dass die Eingaben geprüft werden."):
-            MathOperations.square_root("abc")
-
-    def test_square_root_none_input(self):
-        """
-        Prüft, ob 'square_root' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe die Eingabevalidierung."):
-            MathOperations.square_root(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ✅
-2. "squere_root" Funkton existiert ✅
-3. Berechnet die Qadratwurzel einer positiven Ganzzahl ✅
-4. Wirft einen ValueError für eine negativen Ganzzahl ✅
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ✅
-6. Berechnet die Qadratwurzel von 0 ✅
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ✅
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/9**
-
----
-
-```
-import unittest
-from math_operations import MathOperations
-
-class TestMathOperations(unittest.TestCase):
-
-    def test_class_exists(self):
-        """
-        Prüft, ob die Klasse 'MathOperations' existiert.
-        """
-        self.assertTrue(hasattr(MathOperations, 'square_root'), 
-                        "'MathOperations' soll die Methode 'square_root' enthalten. Überprüfe die Definition.")
-
-    def test_square_root_exists(self):
-        """
-        Prüft, ob die Methode 'square_root' existiert.
-        """
-        self.assertTrue(callable(getattr(MathOperations, 'square_root', None)), 
-                        "'square_root' soll als Methode existieren. Stelle sicher, dass die Methode definiert ist.")
-
-    def test_square_root_positive_number(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer positiven Zahl korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(4), 2.0, 
-                         "'square_root' soll die Quadratwurzel einer positiven Zahl berechnen. Überprüfe, ob die Berechnung korrekt ist.")
-
-    def test_square_root_zero(self):
-        """
-        Prüft, ob 'square_root' für die Eingabe '0' korrekt funktioniert.
-        """
-        self.assertEqual(MathOperations.square_root(0), 0.0, 
-                         "'square_root' soll die Quadratwurzel von '0' als '0.0' zurückgeben. Stelle sicher, dass diese Eingabe behandelt wird.")
-
-    def test_square_root_large_number(self):
-        """
-        Prüft, ob 'square_root' mit großen Zahlen korrekt funktioniert.
-        """
-        self.assertEqual(MathOperations.square_root(1e6), 1000.0, 
-                         "'square_root' soll mit großen Zahlen korrekt umgehen können. Überprüfe die Berechnung für solche Eingaben.")
-
-    def test_square_root_negative_number(self):
-        """
-        Prüft, ob 'square_root' bei einer negativen Eingabe einen Wertfehler auslöst.
-        """
-        with self.assertRaises(ValueError, 
-                               msg="'square_root' soll bei negativen Eingaben einen Wertfehler auslösen. Stelle sicher, dass negative Zahlen korrekt behandelt werden."):
-            MathOperations.square_root(-4)
-
-    def test_square_root_float_input(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer Kommazahl korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(2.25), 1.5, 
-                               "'square_root' soll die Quadratwurzel einer Kommazahl korrekt berechnen. Überprüfe die Genauigkeit bei solchen Eingaben.")
-
-    def test_square_root_invalid_type_string(self):
-        """
-        Prüft, ob 'square_root' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, 
-                               msg="'square_root' soll für String-Eingaben einen Typfehler werfen. Überprüfe die Typvalidierung."):
-            MathOperations.square_root("a")
-
-    def test_square_root_invalid_type_none(self):
-        """
-        Prüft, ob 'square_root' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, 
-                               msg="'square_root' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe die Typvalidierung."):
-            MathOperations.square_root(None)
-
-    def test_square_root_invalid_type_list(self):
-        """
-        Prüft, ob 'square_root' bei Listen-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, 
-                               msg="'square_root' soll für Listen-Eingaben einen Typfehler werfen. Überprüfe die Typvalidierung."):
-            MathOperations.square_root([4])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ✅
-2. "squere_root" Funkton existiert ✅
-3. Berechnet die Qadratwurzel einer positiven Ganzzahl ✅
-4. Wirft einen ValueError für eine negativen Ganzzahl ✅
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ✅
-6. Berechnet die Qadratwurzel von 0 ✅
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ✅
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/9**
-
----
-
-```
-import unittest
-import math
-
-class TestMathOperations(unittest.TestCase):
-
-    def test_class_exists(self):
-        """
-        Prüft, ob die Klasse 'MathOperations' existiert.
-        """
-        self.assertTrue('MathOperations' in globals(), "'MathOperations' soll existieren. Vergewissere dich, dass die Klasse definiert ist.")
-
-    def test_square_root_function_exists(self):
-        """
-        Prüft, ob die Funktion 'square_root' existiert.
-        """
-        self.assertTrue(hasattr(MathOperations, 'square_root') and callable(getattr(MathOperations, 'square_root')), 
-                        "'square_root' soll in der Klasse 'MathOperations' existieren. Vergewissere dich, dass die Methode definiert ist.")
-
-    def test_square_root_positive_integer(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer positiven Ganzzahl korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(16), 4.0, 
-                         "'square_root' soll die Quadratwurzel einer positiven Ganzzahl berechnen. Überprüfe, ob der Algorithmus korrekt ist.")
-
-    def test_square_root_positive_float(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel einer positiven Fließkommazahl korrekt berechnet.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(2.25), 1.5, 
-                               "'square_root' soll die Quadratwurzel einer positiven Fließkommazahl berechnen. Stelle sicher, dass Fließkommazahlen korrekt behandelt werden.")
-
-    def test_square_root_zero(self):
-        """
-        Prüft, ob 'square_root' die Quadratwurzel von 0 korrekt berechnet.
-        """
-        self.assertEqual(MathOperations.square_root(0), 0.0, 
-                         "'square_root' soll die Quadratwurzel von 0 korrekt berechnen. Vergewissere dich, dass der Sonderfall '0' richtig behandelt wird.")
-
-    def test_square_root_negative_input(self):
-        """
-        Prüft, ob 'square_root' bei einer negativen Eingabe einen Wertfehler auslöst.
-        """
-        with self.assertRaises(ValueError, msg="'square_root' soll bei einer negativen Eingabe einen 'ValueError' werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            MathOperations.square_root(-4)
-
-    def test_square_root_large_number(self):
-        """
-        Prüft, ob 'square_root' mit sehr großen Zahlen korrekt umgeht.
-        """
-        self.assertAlmostEqual(MathOperations.square_root(1e10), 1e5, 
-                               "'square_root' soll mit sehr großen Zahlen korrekt arbeiten. Überprüfe die Berechnung bei extremen Eingabewerten.")
-
-    def test_square_root_invalid_type_string(self):
-        """
-        Prüft, ob 'square_root' bei einer String-Eingabe einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll bei einer String-Eingabe einen Typfehler werfen. Vergewissere dich, dass der Eingabetyp überprüft wird."):
-            MathOperations.square_root("16")
-
-    def test_square_root_invalid_type_none(self):
-        """
-        Prüft, ob 'square_root' bei einer 'None'-Eingabe einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'square_root' soll bei einer 'None'-Eingabe einen Typfehler werfen. Überprüfe, ob der Eingabetyp überprüft wird."):
-            MathOperations.square_root(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "MathOperations" Klasse existiert ✅
-2. "squere_root" Funkton existiert ✅
-3. Berechnet die Qadratwurzel einer positiven Ganzzahl ✅
-4. Wirft einen ValueError für eine negativen Ganzzahl ✅
-5. Berechnet die Quadarwurzel von einer Gleitkommazahl ✅
-6. Berechnet die Qadratwurzel von 0 ✅
-7. Berechnet die Qadratwurzel von einer sehr großen Zahl ✅
-8. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-9. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/9**
-
-***Total: 27/27***
-
-### **Test 4:**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mean_of_integers(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3, 4, 5]), 3.0, "'calculate_mean' soll den Durchschnitt von Ganzzahlen korrekt berechnen.")
-
-    def test_mean_of_floats(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Kommazahlen korrekt berechnet.
-        """
-        self.assertAlmostEqual(calculate_mean([1.2, 3.4, 5.6]), 3.4, "'calculate_mean' soll den Durchschnitt von Kommazahlen korrekt berechnen.")
-
-    def test_mean_of_mixed_types(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Ganzzahlen und Kommazahlen korrekt berechnet.
-        """
-        self.assertAlmostEqual(calculate_mean([1, 2.5, 3]), 2.1666666666666665, "'calculate_mean' soll den Durchschnitt von gemischten Typen korrekt berechnen.")
-
-    def test_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer leeren Liste 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll bei einer leeren Liste 'None' zurückgeben.")
-
-    def test_list_with_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer Liste mit einem String 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, "a", 3]), "'calculate_mean' soll 'None' zurückgeben, wenn die Liste nicht-numerische Werte enthält.")
-
-    def test_list_with_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer Liste mit 'None' 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, None, 3]), "'calculate_mean' soll 'None' zurückgeben, wenn die Liste nicht-numerische Werte enthält.")
-
-    def test_single_integer(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt für eine Liste mit nur einer Ganzzahl korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([5]), 5.0, "'calculate_mean' soll den Durchschnitt für eine Liste mit einem Element korrekt berechnen.")
-
-    def test_single_float(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt für eine Liste mit nur einer Kommazahl korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([2.5]), 2.5, "'calculate_mean' soll den Durchschnitt für eine Liste mit einem Element korrekt berechnen.")
-
-    def test_large_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertAlmostEqual(calculate_mean([1e10, 1e10, 1e10]), 1e10, "'calculate_mean' soll mit sehr großen Zahlen korrekt umgehen.")
-
-    def test_invalid_input_not_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht-listenförmigen Eingaben 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean(123), "'calculate_mean' soll 'None' zurückgeben, wenn die Eingabe kein Listentyp ist.")
-        self.assertIsNone(calculate_mean("123"), "'calculate_mean' soll 'None' zurückgeben, wenn die Eingabe kein Listentyp ist.")
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mean_of_integers(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2, "'calculate_mean' soll den Durchschnitt einer Liste von Ganzzahlen korrekt berechnen.")
-
-    def test_mean_of_floats(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5, "'calculate_mean' soll den Durchschnitt einer Liste von Kommazahlen korrekt berechnen.")
-
-    def test_mean_of_mixed_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt einer Liste von Ganzzahlen und Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2.5, 3]), 2.1666666666666665, "'calculate_mean' soll den Durchschnitt einer gemischten Liste aus Ganzzahlen und Kommazahlen korrekt berechnen.")
-
-    def test_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer leeren Liste 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll bei einer leeren Liste 'None' zurückgeben. Überprüfe, ob die Länge der Liste geprüft wird.")
-
-    def test_invalid_type_in_list_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer Liste mit Strings 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, "a", 3]), "'calculate_mean' soll bei einer Liste mit Strings 'None' zurückgeben. Überprüfe, ob alle Elemente auf Zahlen geprüft werden.")
-
-    def test_invalid_type_in_list_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer Liste mit 'None' 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, None, 3]), "'calculate_mean' soll bei einer Liste mit 'None' 'None' zurückgeben. Stelle sicher, dass ungültige Typen korrekt behandelt werden.")
-
-    def test_mean_with_large_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(calculate_mean([1e10, 2e10, 3e10]), 2e10, "'calculate_mean' soll mit sehr großen Zahlen umgehen können.")
-
-    def test_mean_with_negative_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' mit negativen Zahlen korrekt umgeht.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2, "'calculate_mean' soll mit negativen Zahlen korrekt umgehen.")
-
-    def test_mean_with_zero(self):
-        """
-        Prüft, ob 'calculate_mean' den Durchschnitt korrekt berechnet, wenn '0' in der Liste enthalten ist.
-        """
-        self.assertEqual(calculate_mean([0, 2, 4]), 2, "'calculate_mean' soll den Durchschnitt korrekt berechnen, wenn '0' in der Liste enthalten ist.")
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), 
-                        "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_mean_of_integers(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste von Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3, 4]), 2.5, 
-                         "'calculate_mean' soll den Mittelwert einer Liste von Ganzzahlen korrekt berechnen.")
-
-    def test_mean_of_floats(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste von Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.1, 2.2, 3.3, 4.4]), 2.75, 
-                         "'calculate_mean' soll den Mittelwert einer Liste von Kommazahlen korrekt berechnen.")
-
-    def test_mean_of_mixed_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste mit Ganzzahlen und Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2.2, 3, 4.4]), 2.65, 
-                         "'calculate_mean' soll den Mittelwert einer Liste mit Ganzzahlen und Kommazahlen korrekt berechnen.")
-
-    def test_mean_of_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' bei einer leeren Liste 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([]), 
-                          "'calculate_mean' soll bei einer leeren Liste 'None' zurückgeben.")
-
-    def test_mean_with_invalid_element_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei einem String in der Liste 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, "a", 3]), 
-                          "'calculate_mean' soll bei ungültigen Elementen wie Strings in der Liste 'None' zurückgeben.")
-
-    def test_mean_with_invalid_element_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei einem 'None'-Element in der Liste 'None' zurückgibt.
-        """
-        self.assertIsNone(calculate_mean([1, None, 3]), 
-                          "'calculate_mean' soll bei ungültigen Elementen wie 'None' in der Liste 'None' zurückgeben.")
-
-    def test_mean_with_large_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' mit sehr großen Zahlen korrekt umgeht.
-        """
-        self.assertEqual(calculate_mean([1e10, 2e10, 3e10]), 2e10, 
-                         "'calculate_mean' soll mit sehr großen Zahlen korrekt umgehen.")
-
-    def test_mean_with_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste mit einem Element korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([5]), 5, 
-                         "'calculate_mean' soll den Mittelwert einer Liste mit einem Element korrekt berechnen.")
-
-    def test_mean_with_negative_numbers(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste mit negativen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3, -4]), -2.5, 
-                         "'calculate_mean' soll den Mittelwert einer Liste mit negativen Zahlen korrekt berechnen.")
-
-    def test_mean_with_all_zeros(self):
-        """
-        Prüft, ob 'calculate_mean' den Mittelwert einer Liste mit Nullen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([0, 0, 0]), 0, 
-                         "'calculate_mean' soll den Mittelwert einer Liste mit Nullen korrekt berechnen.")
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 8/10**
-
-***Total: 23/30***
-
-### **Test 5:**
-
----
-
-```
-import unittest
-
-class TestIsLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_typical_leap_year(self):
-        """
-        Prüft, ob ein typisches Schaltjahr korrekt erkannt wird.
-        """
-        self.assertTrue(is_leap_year(2024), "'is_leap_year' soll erkennen, dass 2024 ein Schaltjahr ist. Überprüfe die Bedingung für durch 4 teilbare Jahre.")
-
-    def test_typical_non_leap_year(self):
-        """
-        Prüft, ob ein typisches Nicht-Schaltjahr korrekt erkannt wird.
-        """
-        self.assertFalse(is_leap_year(2023), "'is_leap_year' soll erkennen, dass 2023 kein Schaltjahr ist. Überprüfe die Bedingung für nicht durch 4 teilbare Jahre.")
-
-    def test_century_non_leap_year(self):
-        """
-        Prüft, ob ein Jahrhundertjahr, das kein Schaltjahr ist, korrekt erkannt wird.
-        """
-        self.assertFalse(is_leap_year(1900), "'is_leap_year' soll erkennen, dass 1900 kein Schaltjahr ist. Stelle sicher, dass die Bedingung für durch 100 teilbare Jahre ohne durch 400 teilbar erfüllt ist.")
-
-    def test_century_leap_year(self):
-        """
-        Prüft, ob ein Jahrhundertjahr, das ein Schaltjahr ist, korrekt erkannt wird.
-        """
-        self.assertTrue(is_leap_year(2000), "'is_leap_year' soll erkennen, dass 2000 ein Schaltjahr ist. Überprüfe die Bedingung für durch 400 teilbare Jahre.")
-
-    def test_edge_case_year_0(self):
-        """
-        Prüft, ob das Jahr 0 korrekt als Schaltjahr erkannt wird.
-        """
-        self.assertTrue(is_leap_year(0), "'is_leap_year' soll erkennen, dass das Jahr 0 ein Schaltjahr ist. Überprüfe, ob die Funktion für sehr kleine Zahlen korrekt funktioniert.")
-
-    def test_negative_leap_year(self):
-        """
-        Prüft, ob ein negatives Jahr korrekt als Schaltjahr erkannt wird.
-        """
-        self.assertTrue(is_leap_year(-4), "'is_leap_year' soll erkennen, dass -4 ein Schaltjahr ist. Vergewissere dich, dass negative Eingaben korrekt verarbeitet werden.")
-
-    def test_negative_non_leap_year(self):
-        """
-        Prüft, ob ein negatives Jahr korrekt als Nicht-Schaltjahr erkannt wird.
-        """
-        self.assertFalse(is_leap_year(-1), "'is_leap_year' soll erkennen, dass -1 kein Schaltjahr ist. Überprüfe die Logik für negative Zahlen.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob bei String-Eingaben ein Typfehler ausgelöst wird.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year("2024")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob bei 'None'-Eingaben ein Typfehler ausgelöst wird.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(None)
-
-    def test_invalid_type_float(self):
-        """
-        Prüft, ob bei Fließkomma-Eingaben ein Typfehler ausgelöst wird.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für Fließkomma-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(2024.0)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ✅
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ✅
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/6**
-
----
-
-```
-import unittest
-
-class TestIsLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_typical_leap_year(self):
-        """
-        Prüft, ob typische Schaltjahre korrekt erkannt werden.
-        """
-        self.assertTrue(is_leap_year(2024), "'is_leap_year' soll erkennen, dass 2024 ein Schaltjahr ist.")
-
-    def test_typical_non_leap_year(self):
-        """
-        Prüft, ob typische Nicht-Schaltjahre korrekt erkannt werden.
-        """
-        self.assertFalse(is_leap_year(2023), "'is_leap_year' soll erkennen, dass 2023 kein Schaltjahr ist.")
-
-    def test_century_non_leap_year(self):
-        """
-        Prüft, ob Jahrhunderte, die keine Schaltjahre sind, korrekt erkannt werden.
-        """
-        self.assertFalse(is_leap_year(1900), "'is_leap_year' soll erkennen, dass 1900 kein Schaltjahr ist.")
-
-    def test_century_leap_year(self):
-        """
-        Prüft, ob Jahrhunderte, die Schaltjahre sind, korrekt erkannt werden.
-        """
-        self.assertTrue(is_leap_year(2000), "'is_leap_year' soll erkennen, dass 2000 ein Schaltjahr ist.")
-
-    def test_edge_case_min_year(self):
-        """
-        Prüft, ob der kleinste mögliche Jahreswert korrekt behandelt wird.
-        """
-        self.assertFalse(is_leap_year(1), "'is_leap_year' soll erkennen, dass 1 kein Schaltjahr ist.")
-
-    def test_edge_case_zero_year(self):
-        """
-        Prüft, ob das Jahr 0 korrekt als Schaltjahr behandelt wird.
-        """
-        self.assertTrue(is_leap_year(0), "'is_leap_year' soll erkennen, dass 0 ein Schaltjahr ist.")
-
-    def test_edge_case_large_year(self):
-        """
-        Prüft, ob sehr große Jahreswerte korrekt verarbeitet werden.
-        """
-        self.assertTrue(is_leap_year(4000000), "'is_leap_year' soll erkennen, dass 4000000 ein Schaltjahr ist.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'is_leap_year' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year("2024")
-
-    def test_invalid_type_float(self):
-        """
-        Prüft, ob 'is_leap_year' bei Fließkommazahlen einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für Fließkommazahlen einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(2024.0)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'is_leap_year' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ✅
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ✅
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/6**
-
----
-
-```
-import unittest
-
-class TestIsLeapYearFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'is_leap_year' existiert.
-        """
-        self.assertTrue(callable(is_leap_year), "'is_leap_year' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_typical_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' ein typisches Schaltjahr korrekt identifiziert.
-        """
-        self.assertTrue(is_leap_year(2024), "'is_leap_year' soll 2024 als Schaltjahr identifizieren. Überprüfe die Logik für Jahre, die durch 4 teilbar sind.")
-
-    def test_typical_non_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' ein typisches Nicht-Schaltjahr korrekt identifiziert.
-        """
-        self.assertFalse(is_leap_year(2023), "'is_leap_year' soll 2023 als Nicht-Schaltjahr identifizieren. Überprüfe die Logik für Jahre, die nicht durch 4 teilbar sind.")
-
-    def test_century_non_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' ein Jahrhundertjahr, das kein Schaltjahr ist, korrekt erkennt.
-        """
-        self.assertFalse(is_leap_year(1900), "'is_leap_year' soll 1900 als Nicht-Schaltjahr identifizieren. Überprüfe die Logik für Jahre, die durch 100, aber nicht durch 400 teilbar sind.")
-
-    def test_century_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' ein Jahrhundertjahr, das ein Schaltjahr ist, korrekt erkennt.
-        """
-        self.assertTrue(is_leap_year(2000), "'is_leap_year' soll 2000 als Schaltjahr identifizieren. Überprüfe die Logik für Jahre, die durch 400 teilbar sind.")
-
-    def test_negative_year(self):
-        """
-        Prüft, ob 'is_leap_year' für ein negatives Jahr korrekt funktioniert.
-        """
-        self.assertFalse(is_leap_year(-1), "'is_leap_year' soll für das Jahr -1 korrekt arbeiten. Überprüfe die Handhabung negativer Eingaben.")
-
-    def test_year_zero(self):
-        """
-        Prüft, ob 'is_leap_year' für das Jahr 0 korrekt funktioniert.
-        """
-        self.assertTrue(is_leap_year(0), "'is_leap_year' soll das Jahr 0 als Schaltjahr identifizieren. Überprüfe die Logik für spezielle Fälle.")
-
-    def test_large_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' für eine große Schaltjahr-Zahl korrekt funktioniert.
-        """
-        self.assertTrue(is_leap_year(2400), "'is_leap_year' soll 2400 als Schaltjahr identifizieren. Überprüfe die Logik für große Zahlen.")
-
-    def test_large_non_leap_year(self):
-        """
-        Prüft, ob 'is_leap_year' für eine große Nicht-Schaltjahr-Zahl korrekt funktioniert.
-        """
-        self.assertFalse(is_leap_year(2300), "'is_leap_year' soll 2300 als Nicht-Schaltjahr identifizieren. Überprüfe die Logik für große Zahlen.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'is_leap_year' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year("2024")
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'is_leap_year' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(None)
-
-    def test_invalid_type_float(self):
-        """
-        Prüft, ob 'is_leap_year' bei Fließkommazahlen einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'is_leap_year' soll für Fließkommazahlen einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."):
-            is_leap_year(2024.5)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-### **Auswertung**
-1. "is_leap_year" Funkton existiert ✅
-2. Mehrere Schaltjahre werden richtig als Schaltjahr erkannt ✅
-3. Mehrere nicht Schaltjahre richtig als nicht Schaltjahre erkannt ✅
-4. Ein Jahre das durch 100 aber nicht durch 400 teilbar ist wird richtig als nicht Schaltjahr erkannt ✅
-5. Wirft einen Typfehler für nicht integer Eingaben (z.B. Gleitkommazahlen oder Strings) ✅
-6. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/6**
-
-***Total: 18/18***
diff --git a/appx/modelluntersuchung.md b/appx/modelluntersuchung.md
deleted file mode 100644
index 68c7afd031132ef737371c049c9101fa93125ad1..0000000000000000000000000000000000000000
--- a/appx/modelluntersuchung.md
+++ /dev/null
@@ -1,1229 +0,0 @@
-# **Modelluntersuchung**
-
-In dieser Analyse werden verschiedene **KI-Modelle** systematisch auf ihre Leistungsfähigkeit bei der Testgenerierung untersucht. Hierzu wurde jedes Modell dreimal mit einem einheitlichen **Standardprompt** getestet.
-
-Die generierten Ergebnisse wurden mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Die abschließende Gegenüberstellung der Ergebnisse erfolgt in einer **Auswertungstabelle**, die zur besseren Übersicht am Anfang des Dokuments platziert ist.
-
----
-
-## **Auswertungstabelle**
-
-| **Modell**           | **Iteration 1** | **Iteration 2** | **Iteration 3** | **Total** | **Prozent** |
-|-----------------------|------------|------------|------------|-----------|-------------|
-| **Mistral**          | 5/10       | 6/10       | 6/10       | 17/30     | 56,67%      |
-| **Llama3**           | 6/10       | 6/10       | 6/10       | 18/30     | 60,00%      |
-| **CodeLlama**        | 5/10       | 4/10       | 4/10       | 13/30     | 43,33%      |
-| **StarCoder2**       | 0/10       | 0/10       | 0/10       | 0/30      | 0,00%       |
-| **Gemma2**           | 4/10       | 4/10       | 4/10       | 12/30     | 40,00%      |
-| **CodeGemma**        | 5/10       | 5/10       | 5/10       | 15/30     | 50,00%      |
-| **Gemini 1.5 Flash** | 6/10       | 6/10       | 7/10       | 19/30     | 63,33%      |
-| **GPT-4o**           | 7/10       | 7/10       | 8/10       | 22/30     | 73,33%      |
-
----
-
-## **Standardprompt**
-
-```
-You are a Python test generation tool. Generate a comprehensive test suite for the provided code. Ensure that you:
-- Include test cases for syntax validation, class and function existence, overall behavior, and edge cases.
-- Output only the Python test suite without explanations or additional comments.
-Code: 
-def add(a, b):
-    return a+b
-```
-
----
-
-## **KI-Modelle**
-1. mistral:7b
-2. llama3:8b
-3. codellama:7b
-4. starcoder2:7b
-5. gemma2:9b
-6. codegemma:7b
-7. Gemini 1.5 flash
-8. ChatGPT 4o
-
-## **Mistral**
-
----
-
-```python
-import unittest
-from your_module import add
-
-class TestAddFunction(unittest.TestCase):
-    def test_syntax_validation(self):
-        self.assertIsInstance(add, type)
-
-    def test_class_and_function_existence(self):
-        self.assertTrue(hasattr(your_module, 'add'))
-
-    def test_basic_behavior(self):
-        self.assertEqual(add(1, 2), 3)
-        self.assertEqual(add(-1, -2), -3)
-        self.assertEqual(add(0, 0), 0)
-
-    def test_edge_cases(self):
-        self.assertEqual(add(sys.maxsize, 1), sys.maxsize + 1)
-        self.assertEqual(add(-sys.maxsize - 1, -1), -sys.maxsize - 2)
-        self.assertEqual(add(-sys.maxsize, sys.maxsize), 0)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-```python
-import unittest
-from your_module import add  # replace 'your_module' with the appropriate 
-module name
-
-class TestAddFunction(unittest.TestCase):
-    def test_syntax_validation(self):
-        self.assertRaises(TypeError, add)
-        self.assertRaises(TypeError, add, 1, "not a number")
-        self.assertRaises(TypeError, add, None, 2)
-        self.assertIsInstance(add(1, 2), int)
-
-    def test_class_and_function_existence(self):
-        self.assertIsNotNone(add)
-        self.assertTrue(callable(add))
-
-    def test_behavior(self):
-        self.assertEqual(add(1, 2), 3)
-        self.assertEqual(add(-1, 1), 0)
-        self.assertEqual(add(99999, 1), 100000)
-        self.assertEqual(add(0, 0), 0)
-
-    def test_edge_cases(self):
-        self.assertEqual(add(-100000, 1), -99999)
-        self.assertEqual(add(sys.maxsize, 1), sys.maxsize + 1)
-        self.assertEqual(add(sys.maxsize, -1), sys.maxsize - 1)
-        self.assertEqual(add(-sys.maxsize, -1), -sys.maxsize + 1)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ❌
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-```python
-import unittest
-from your_module import add
-
-class TestAddFunction(unittest.TestCase):
-    def test_syntax_validation(self):
-        self.assertIsInstance(add, type)
-
-    def test_function_existence(self):
-        self.assertTrue(callable(add))
-
-    def test_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-        self.assertEqual(add(10, 4), 14)
-
-    def test_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-        self.assertEqual(add(-10, -4), -14)
-
-    def test_zero(self):
-        self.assertEqual(add(0, 4), 4)
-        self.assertEqual(add(4, 0), 4)
-
-    def test_float_numbers(self):
-        self.assertAlmostEqual(add(2.5, 3.7), 6.2)
-        self.assertAlmostEqual(add(-2.5, -3.7), -6.2)
-
-    def test_mixed_types(self):
-        with self.assertRaises(TypeError):
-            add('str', 4)
-        with self.assertRaises(TypeError):
-            add(4, 'str')
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
-***Total: 17/30**
-
----
-
-Llama3:8b
-
----
-
-```
-import unittest
-class TestAddFunction(unittest.TestCase):
-    def test_syntax(self):
-        self.assertIsNotNone(add)
-
-    def test_class_existence(self):
-        self.assertIs(type(add), type((lambda x: None)))
-
-    def test_function_type(self):
-        self.assertIsInstance(add, type(abs))
-
-    def test_valid_input(self):
-        self.assertEqual(add(1, 2), 3)
-        self.assertEqual(add(-1, -2), -3)
-        self.assertEqual(add(0, 0), 0)
-
-    def test_invalid_input_type_integer(self):
-        with self.assertRaises(TypeError):
-            add('a', 2)
-        with self.assertRaises(TypeError):
-            add(1, 'b')
-
-    def test_invalid_input_type_non_numeric(self):
-        with self.assertRaises(TypeError):
-            add(None, None)
-        with self.assertRaises(TypeError):
-            add([], [])
-        with self.assertRaises(TypeError):
-            add({}, {})
-
-    def test_edge_case_negative_numbers(self):
-        self.assertEqual(add(-10, 2), -8)
-        self.assertEqual(add(0, -1), -1)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-```
-import unittest
-class TestAddFunction(unittest.TestCase):
-
-    def test_syntax(self):
-        pass
-
-    def test_class_and_function_existence(self):
-        self.assertIsNotNone(add)
-        self.assertTrue(callable(add))
-
-    def test_addition(self):
-        self.assertEqual(add(1, 2), 3)
-        self.assertEqual(add(-1, -2), -3)
-        self.assertEqual(add(-1, 2), 1)
-        self.assertEqual(add(0, 0), 0)
-
-    def test_edge_cases(self):
-        self.assertRaises(TypeError, add, 'a', 2)
-        self.assertRaises(TypeError, add, 2, 'b')
-        self.assertEqual(add(None, None), None)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-```
-import unittest
-class TestAddFunction(unittest.TestCase):
-
-    def test_syntax(self):
-        self.assertEqual(add("hello", 5), None)
-
-    def test_function_exists(self):
-        self.assertIsNotNone(add)
-    
-    def test_addition(self):
-        self.assertEqual(add(1, 2), 3)
-
-    def test_edge_case_zero(self):
-        self.assertEqual(add(-1,0),-1)
-
-    def test_edge_case_negative_numbers(self):
-        self.assertEqual(add(-5,-7), -12)
-
-    def test_edge_case_large_integers(self):
-        self.assertEqual(add(100000,200000), 300000)
-
-    def test_edge_case_floating_point(self):
-        self.assertAlmostEqual(add(0.1, 2.3), 2.4)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
-***Total: 18/30***
-
----
-
-## **codellama**
-
----
-
-import unittest
-
-class TestAdd(unittest.TestCase):
-    def test_add_positive(self):
-        self.assertEqual(add(1, 2), 3)
-
-    def test_add_negative(self):
-        self.assertEqual(add(-1, -2), -3)
-
-    def test_add_floats(self):
-        self.assertAlmostEqual(add(1.5, 2.5), 4)
-
-    def test_add_mixed(self):
-        self.assertEqual(add(1, 2.0), 3.0)
-
-    def test_add_type_error(self):
-        with self.assertRaises(TypeError):
-            add('a', 'b')
-
-    def test_add_value_error(self):
-        with self.assertRaises(ValueError):
-            add('a', 1)
-
-if __name__ == '__main__':
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(1, 2), 3)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-1, -2), -3)
-
-    def test_add_float_numbers(self):
-        self.assertEqual(add(1.5, 2.5), 4)
-
-    def test_add_string(self):
-        with self.assertRaises(TypeError):
-            add("hello", "world")
-
-    def test_add_none(self):
-        with self.assertRaises(TypeError):
-            add(None, None)
-
-if __name__ == '__main__':
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
----
-
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-    def test_add_two_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_floats(self):
-        self.assertAlmostEqual(add(2.5, 3.5), 6, places=1)
-
-    def test_add_with_strings(self):
-        with self.assertRaises(TypeError):
-            add("hello", "world")
-
-class TestAddClass(unittest.TestCase):
-    def setUp(self):
-        self.adder = add
-
-    def test_add_two_numbers(self):
-        self.assertEqual(self.adder(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(self.adder(-2, -3), -5)
-
-    def test_add_floats(self):
-        self.assertAlmostEqual(self.adder(2.5, 3.5), 6, places=1)
-
-    def test_add_with_strings(self):
-        with self.assertRaises(TypeError):
-            self.adder("hello", "world")
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
-***Total: 13/30***
-
----
-
-## **StarCoder2**
-
----
-
-def is_even(x):
-    return x % 2 == 0
-###Punkte: 0
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ❌
-3. Addiert zwei negative Ganzzahlen ❌
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 0/10**
-
----
-
-Test:
-add(1, 2) == 3
-add(256, 257) == 513
-add('a', 'b') == 'ab'
-
-
-Example
-Input: 
-def add(a, b):
-    return a+b
-
-Output:
-add(1, 2) == 3
-add(256, 257) == 513
-add('a', 'b') == 'ab'
-###Punkte: 0
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ❌
-3. Addiert zwei negative Ganzzahlen ❌
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 0/10**
-
----
-
-Testing criteria (10 points):
-- Validate that a function is syntactically correct (use `exec` and 
-`compile`)
-- Validate that a function exists
-- Validate the output of a function (e.g., a+b=3)
-- Validate a range of inputs for the function, e.g., 0 + 1 = 1
-- Output the test case as you see fit. E.g., `add(1,2)` or `add(a=1, 
-b=2)`.
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ❌
-3. Addiert zwei negative Ganzzahlen ❌
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ❌
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 0/10**
-
-***Total: 0/30***
-
----
-
-## **gemme2**
-
----
-
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-    def test_syntax(self):
-        assert "def add(a, b):" in globals()
-
-    def test_function_exists(self):
-        assert callable(globals()['add'])
-
-    def test_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_zero(self):
-        self.assertEqual(add(0, 5), 5)
-
-    def test_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_float_numbers(self):
-        self.assertEqual(add(2.5, 3.7), 6.2)
-
-if __name__ == '__main__':
-    unittest.main()  
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
----
-
-2. ###
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-
-    def test_syntax(self):
-        pass
-
-    def test_add_existence(self):
-        self.assertTrue(hasattr(globals(), 'add'))
-
-    def test_add_function(self):
-        self.assertEqual(add(2, 3), 5)
-        self.assertEqual(add(-1, 1), 0)
-        self.assertEqual(add(0, 0), 0)
-
-    def test_add_edge_cases(self):
-        self.assertEqual(add(float('inf'), 1), float('inf'))
-        self.assertEqual(add(-float('inf'), -1), -float('inf'))
-
-
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ❌
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
----
-
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-
-    def test_syntax(self):
-        exec("def add(a, b): return a + b")
-
-    def test_function_existence(self):
-        with self.assertRaises(NameError):
-            globals().pop('add', None)
-        
-    def test_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_zero(self):
-        self.assertEqual(add(0, 5), 5)
-        self.assertEqual(add(5, 0), 5)
-
-    def test_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_float_numbers(self):
-        self.assertEqual(add(2.5, 3.7), 6.2)
-
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
-***Total: 12/30***
-
----
-
-## **codegemma**
-
----
-
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 0), 0)
-
-    def test_add_float(self):
-        self.assertEqual(add(2.5, 3.5), 6)
-
-    def test_add_non_numeric_types(self):
-        with self.assertRaises(TypeError):
-            add("a", "b")
-
-    def test_add_missing_arguments(self):
-        with self.assertRaises(TypeError):
-            add(2)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_mixed_numbers(self):
-        self.assertEqual(add(2, -3), -1)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 0), 0)
-
-    def test_add_non_numeric_values(self):
-        with self.assertRaises(TypeError):
-            add('a', 'b')
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-```python
-import unittest
-
-class TestAdd(unittest.TestCase):
-
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_mixed_numbers(self):
-        self.assertEqual(add(2, -3), -1)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 0), 0)
-
-    def test_add_none(self):
-        self.assertRaises(TypeError, add, None, 3)
-
-    def test_add_empty_string(self):
-        self.assertRaises(TypeError, add, "", 3)
-
-    def test_add_list(self):
-        self.assertRaises(TypeError, add, [1, 2], 3)
-
-    def test_add_dictionary(self):
-        self.assertRaises(TypeError, add, {1: 2}, 3)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ❌
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
-***Total: 15/30***
-
----
-
-## **gemini 1.5 Flash**
-
----
-
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_add_positive_integers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_integers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_mixed_signs(self):
-        self.assertEqual(add(2, -3), -1)
-        self.assertEqual(add(-2, 3), 1)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 5), 5)
-        self.assertEqual(add(5, 0), 5)
-
-    def test_add_large_numbers(self):
-        self.assertEqual(add(1000000, 999999), 1999999)
-
-    def test_add_floating_point_numbers(self):
-        self.assertAlmostEqual(add(1.23, 4.56), 5.79, places=2)
-
-if __name__ == '__main__':
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_mixed_signs(self):
-        self.assertEqual(add(2, -3), -1)
-        self.assertEqual(add(-2, 3), 1)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 5), 5)
-        self.assertEqual(add(5, 0), 5)
-
-    def test_add_float_numbers(self):
-        self.assertEqual(add(2.5, 3.7), 6.2)
-
-    def test_add_large_numbers(self):
-        self.assertEqual(add(1000000, 999999), 1999999)
-
-if __name__ == '__main__':
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_add_positive_numbers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_numbers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_mixed_signs(self):
-        self.assertEqual(add(2, -3), -1)
-        self.assertEqual(add(-2, 3), 1)
-
-    def test_add_zero(self):
-        self.assertEqual(add(0, 5), 5)
-        self.assertEqual(add(5, 0), 5)
-
-    def test_add_float_numbers(self):
-        self.assertEqual(add(2.5, 3.7), 6.2)
-
-    def test_add_large_numbers(self):
-        self.assertEqual(add(1000000, 2000000), 3000000)
-
-    def test_add_string_input(self):
-        with self.assertRaises(TypeError):
-            add("hello", "world")
-
-if __name__ == '__main__':
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 7/10**
-
-***Total: 19/30***
-
----
-
-## **GPT-4o**
-
----
-
-```python
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(add), "Function 'add' does not exist")
-    
-    def test_syntax_validation(self):
-        try:
-            compile("def add(a, b): return a+b", '<string>', 'exec')
-        except SyntaxError:
-            self.fail("Syntax error in function 'add'")
-
-    def test_addition(self):
-        self.assertEqual(add(1, 2), 3)
-        self.assertEqual(add(-1, -2), -3)
-        self.assertEqual(add(0, 0), 0)
-        self.assertEqual(add(1.5, 2.5), 4.0)
-        self.assertEqual(add(-1.5, 1.5), 0.0)
-    
-    def test_edge_cases(self):
-        self.assertEqual(add(0, 1), 1)
-        self.assertEqual(add(1, 0), 1)
-        self.assertEqual(add(float('inf'), 1), float('inf'))
-        self.assertEqual(add(1, float('inf')), float('inf'))
-        self.assertTrue(add(float('inf'), float('-inf')), "Expected NaN or undefined")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError):
-            add("a", "b")
-        with self.assertRaises(TypeError):
-            add(None, 1)
-        with self.assertRaises(TypeError):
-            add(1, None)
-        with self.assertRaises(TypeError):
-            add([1, 2], [3, 4])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 7/10**
-
----
-
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_add_exists(self):
-        # Check if the function `add` exists
-        self.assertTrue(callable(add))
-
-    def test_add_basic(self):
-        # Basic test cases
-        self.assertEqual(add(1, 1), 2)
-        self.assertEqual(add(-1, -1), -2)
-        self.assertEqual(add(0, 0), 0)
-        self.assertEqual(add(100, 200), 300)
-
-    def test_add_floats(self):
-        # Test with float values
-        self.assertAlmostEqual(add(1.5, 2.5), 4.0)
-        self.assertAlmostEqual(add(-1.5, -2.5), -4.0)
-
-    def test_add_strings(self):
-        # Test with string inputs
-        self.assertEqual(add("hello ", "world"), "hello world")
-        self.assertEqual(add("foo", "bar"), "foobar")
-
-    def test_add_lists(self):
-        # Test with list inputs
-        self.assertEqual(add([1, 2], [3, 4]), [1, 2, 3, 4])
-        self.assertEqual(add([], [1, 2]), [1, 2])
-
-    def test_add_tuples(self):
-        # Test with tuple inputs
-        self.assertEqual(add((1, 2), (3, 4)), (1, 2, 3, 4))
-        self.assertEqual(add((), (1, 2)), (1, 2))
-
-    def test_add_edge_cases(self):
-        # Test with edge cases
-        self.assertEqual(add(float('inf'), 1), float('inf'))
-        self.assertEqual(add(float('-inf'), -1), float('-inf'))
-        self.assertTrue(isinstance(add(None, None), type(None)))
-
-    def test_add_invalid_type(self):
-        # Test with invalid types
-        with self.assertRaises(TypeError):
-            add(1, "a")
-        with self.assertRaises(TypeError):
-            add("a", 1)
-        with self.assertRaises(TypeError):
-            add([1, 2], 3)
-        with self.assertRaises(TypeError):
-            add(3, [1, 2])
-
-if __name__ == "__main__":
-    unittest.main()
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ✅
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ❌
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ❌
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 7/10**
-
----
-
-```python
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_add_positive_integers(self):
-        self.assertEqual(add(2, 3), 5)
-
-    def test_add_negative_integers(self):
-        self.assertEqual(add(-2, -3), -5)
-
-    def test_add_positive_and_negative_integers(self):
-        self.assertEqual(add(5, -3), 2)
-
-    def test_add_zero_and_integer(self):
-        self.assertEqual(add(0, 5), 5)
-        self.assertEqual(add(5, 0), 5)
-
-    def test_add_floats(self):
-        self.assertAlmostEqual(add(2.5, 3.1), 5.6)
-        self.assertAlmostEqual(add(-2.5, -3.1), -5.6)
-
-    def test_add_float_and_integer(self):
-        self.assertAlmostEqual(add(3, 2.5), 5.5)
-        self.assertAlmostEqual(add(2.5, 3), 5.5)
-
-    def test_add_large_numbers(self):
-        self.assertEqual(add(1_000_000, 2_000_000), 3_000_000)
-        self.assertEqual(add(-1_000_000, -2_000_000), -3_000_000)
-
-    def test_add_edge_cases(self):
-        self.assertEqual(add(float('inf'), 1), float('inf'))
-        self.assertEqual(add(-float('inf'), 1), -float('inf'))
-        self.assertTrue(math.isnan(add(float('nan'), 1)))
-
-    def test_add_type_error(self):
-        with self.assertRaises(TypeError):
-            add("a", 1)
-        with self.assertRaises(TypeError):
-            add(1, "b")
-        with self.assertRaises(TypeError):
-            add(None, 1)
-        with self.assertRaises(TypeError):
-            add(1, None)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "add" Funkton existiert ❌
-2. Addiert zwei positive Ganzzahlen ✅
-3. Addiert zwei negative Ganzzahlen ✅
-4. Addiert eine positive und eine negative Ganzzahlen ✅
-5. Addiert zwei Gleitkommazahlen ✅
-6. Addiert eine Gleitkommazahl und eine Ganzzahl ✅
-7. Addiert eine Ganzzahl mit 0 ✅
-8. Addiert mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für nicht-numerische Eingaben (z.B. Zeichenkette oder Liste) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 8/10**
-
-***Total: 22/30***
diff --git a/appx/modellvergleich.md b/appx/modellvergleich.md
deleted file mode 100644
index 02e3b767ba8129d0cd19f9558542bc3b8dd88a3a..0000000000000000000000000000000000000000
--- a/appx/modellvergleich.md
+++ /dev/null
@@ -1,485 +0,0 @@
-# **Modellvergleich**
-
-Diese Analyse untersucht und vergleicht die Leistungsfähigkeit der Modelle **Mistral:7b** (lokal installiert mit Ollama) und **Llama:8b** (lokal installiert mit Ollama) bei der Testgenerierung für **komplexeren Code**. Beide Modelle werden jeweils dreimal mit einem einheitlichen **Standardprompt** getestet.
-
-Die generierten Ergebnisse werden mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Abschließend erfolgt eine Gegenüberstellung der Ergebnisse in einer **Auswertungstabelle**, die zur besseren Übersicht am Anfang des Dokuments platziert wurde.
-
----
-
-## **Auswertungstabelle**
-
-| **Modell**           | **Iteration 1** | **Iteration 2** | **Iteration 3** | **Total** | **Prozent** |
-|-----------------------|------------|------------|------------|-----------|-------------|
-| **Mistral:7b**       | 7/10       | 2/10       | 4/10       | 13/30     | 44,33%      |
-| **Llama:8b**         | 6/10       | 6/10       | 4/10       | 16/30     | 53,33%      |
-
----
-
-## **Standardprompt**
-
-```
-You are a Python test generation tool. Generate a comprehensive test suite for the provided code. Ensure that you:
-- Include test cases for syntax validation, class and function existence, overall behavior, type errors, and edge cases.
-- Provide clear and understandable feedback in German for any failed tests.
-- Output only the Python test suite without explanations or additional comments.
-Code: 
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-## **Mistral:7b**
-
---- 
-
-```python
-import unittest
-from typing import List, Union
-
-class TestCalculateMeanFunction:
-    def test_syntax_validation(self):
-        with self.assertRaises(SyntaxError):
-            exec("def calculate_mean(number_list: list:\n    length = len(number_list)\n    if length == 0:\n        return None\n    for l in number_list:\n        if type(l) != int: \n           if type(l) != float:\n               return None\n    summe = sum(number_list)\n    average = summe / length\n    return average")
-
-    def test_class_and_function_existence(self):
-        self.assertIsInstance(calculate_mean, type)
-        self.assertTrue(callable(calculate_mean))
-
-    def test_overall_behavior(self):
-        self.assertEqual(calculate_mean([]), None)
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0)
-        self.assertEqual(calculate_mean([1.0, 2.0, 3.0]), 2.0)
-
-    def test_type_errors(self):
-        self.assertIsNone(calculate_means([]))
-        with self.assertRaises(TypeError):
-            calculate_mean("not a number")
-        with self.assertRaises(TypeError):
-            calculate_mean([1, "not a number", 3])
-
-    def test_edge_cases(self):
-        self.assertEqual(calculate_mean([0]), 0.0)
-        self.assertEqual(calculate_mean([-1, 1]), 0.0)
-        self.assertAlmostEqual(calculate_mean([5.0, 4.0, 3.0, 2.0, 1.0]), 3.0)
-
-class TestDataTypes:
-    def test_expected_data_types(self):
-        self.assertEqual(type(calculate_mean([])), type(None))
-        self.assertIsInstance(calculate_mean([1, 2, 3]), float)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-
-**Punkte: 7/10**
-
----
-
-```python
-import unittest
-from typing import List, Union
-
-class TestCalculateMeanFunction:
-    def test_syntax_validation(self):
-        with self.assertRaises(SyntaxError):
-            calculate_mean = "def calculate_mean("number_list: list):"
-
-    def test_class_and_function_existence(self):
-        with self.assertRaises(NameError):
-            calculate_mean = None
-
-    def test_empty_input(self):
-        self.assertEqual(calculate_mean([]), None)
-
-    def test_non_numeric_input(self):
-        self.assertEqual(calculate_means([1, "a"]), None)
-
-    def test_mixed_input(self):
-        self.assertEqual(calculate_mean([1, 2.5, "3", 4]), None)
-
-    def test_valid_numeric_input(self):
-        self.assertAlmostEqual(calculate_means([1, 2, 3, 4]), 2.5)
-
-    def test_single_value_input(self):
-        self.assertEqual(calculate_mean([5]), 5)
-
-    def test_multiple_same_values(self):
-        self.assertAlmostEqual(calculate_means([1, 1, 1, 1]), 1)
-
-    def test_large_input(self):
-        self.assertAlmostEqual(calculate_means([1 for i in range(100)]), sum([i for i in range(1, 101)]) / 100)
-
-class TestTypes:
-    def test_list_type(self):
-        self.assertIsInstance(calculate_mean([]), type(None))
-        self.assertIsInstance(calculate_mean([1]), type(None))
-
-    def test_int_or_float_elements(self):
-        self.assertIsInstance(calculate_means([1, 2, 3, 4.5]), list)
-
-class TestValues:
-    def test_minimum_value(self):
-        self.assertEqual(calculate_mean([-999999]), -999999)
-
-    def test_maximum_value(self):
-        self.assertEqual(calculate_mean([999999]), 999999)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-This code provides a test suite for the `calculate_mean` function in 
-Python, covering syntax validation, class and function existence, overall 
-behavior, type errors, and edge cases. The tests are written using the 
-built-in unittest module, and they provide clear and understandable 
-feedback by raising appropriate exceptions or assertions when the provided 
-function fails to meet the test conditions. All tests are written in 
-English and output only the Python test suite without explanations or 
-additional comments.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Viele fehlerhafte oder uneindeutige Testfälle
-
-**Punkte: 2/10**
-
----
-
-```python
-import unittest
-from typing import List, Union
-
-class TestCalculateMeanFunction:
-    def test_syntax_validation(self):
-        self.assertRaises(SyntaxError, compile, 'calculate_mean')
-
-    def test_class_existence(self):
-        self.assertTrue(hasattr(__import__('module_name'), 'calculate_mean'))
-
-    def test_function_existence(self):
-        self.assertIsInstance(__import__('module_name').calculate_mean, type(lambda: None))
-
-    def test_parameter_type(self):
-        self.assertRaises(TypeError, calculate_mean, 1)
-
-    def test_empty_list(self):
-        self.assertEqual(calculate_mean([]), None)
-
-    def test_integer_values(self):
-        self.assertAlmostEqual(calculate_mean([1, 2, 3]), 2)
-
-    def test_float_values(self):
-        self.assertAlmostEqual(calculate_mean([1.0, 2.0, 3.0]), 2)
-
-    def test_mixed_type_list(self):
-        self.assertEqual(calculate_means([1, '2', 3]), None)
-
-    def test_negative_values(self):
-        self.assertAlmostEqual(calculate_mean([-1, -2, 3]), -0.5)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Fehlerhafte Testfälle
-
-**Punkte: 4/10**
-
-***Total: 13/30***
-
----
-
-## **Llama3:8b**
-
----
-
-```
-import unittest
-class TestCalculateMean(unittest.TestCase):
-    def test_syntax(self):
-        pass  # Code compiles without syntax errors, so no tests needed
-
-    def test_class_and_function_existence(self):
-        self.assertIsNotNone(globals().get('calculate_mean'))
-        self.assertIsInstance(calculate_mean, type)
-
-    def test_positive_numbers(self):
-        result = calculate_mean([1, 2, 3])
-        self.assertEqual(result, 2.0)
-    
-    def test_zero_length_list(self):
-        result = calculate_mean([])
-        self.assertIsNone(result)
-    
-    def test_negative_numbers(self):
-        result = calculate_mean([-1, -2, -3])
-        self.assertEqual(result, -2.0)
-    
-    def test_mixed_numbers(self):
-        result = calculate_mean([1, 2, -3, 4])
-        self.assertEqual(result, 0.5)
-
-    def test_floats(self):
-        result = calculate_mean([1.0, 2.5, 3.75])
-        self.assertAlmostEqual(result, 2.4166666666666665)
-
-    def test_non_numeric_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b', 'c'])
-    
-    def test_string_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['1', '2', '3'])
-
-    def test_empty_string_input(self):
-        result = calculate_mean(['', '', ''])
-        self.assertIsNone(result)
-
-    def test_mixed_types_input(self):
-        result = calculate_mean([1, 2.0, 'a', None])
-        self.assertIsNone(result)
-
-    def test_non_iterable_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(None)
-    
-    def test_non_list_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean('not a list')
-    
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-    def test_syntax_validation(self):
-        self.assertIsNone(locals())
-
-    def test_class_and_function_existence(self):
-        from your_module import calculate_mean
-        self.assertIsNotNone(calculate_mean)
-
-    def test_positive_numbers(self):
-        numbers = [1, 2, 3, 4]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 2.5)
-
-    def test_negative_numbers(self):
-        numbers = [-1, -2, -3, -4]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, -2.5)
-
-    def test_mixed_positive_and_negative_numbers(self):
-        numbers = [1, -2, 3, -4]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, -0.25)
-
-    def test_empty_list(self):
-        numbers = []
-        result = calculate_mean(numbers)
-        self.assertIsNone(result)
-
-    def test_non_numeric_values(self):
-        numbers = ['a', 'b', 'c']
-        with self.assertRaises(TypeError):
-            calculate_mean(numbers)
-
-    def test_single_element(self):
-        numbers = [5]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 5)
-
-    def test_two_elements(self):
-        numbers = [1, 2]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 1.5)
-
-    def test_multiple_elements(self):
-        numbers = [-10, -20, 0, 30]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 5.0)
-
-    def test_zero_length_list(self):
-        numbers = [1] + [None] * (100 - 1)
-        result = calculate_mean(numbers[:-1])
-        self.assertIsNone(result)
-
-    def test_string_value(self):
-        numbers = ['a', 'b', 'c']
-        with self.assertRaises(TypeError):
-            calculate_mean(numbers)
-
-    def test_float_values(self):
-        numbers = [1.0, 2.5, 3.8]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 2.433333333333333)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Fehlerhafte Testfälle
-
-**Punkte: 6/10**
-
----
-
-```
-import unittest
-from calculator import calculate_mean
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_syntax(self):
-        try:
-            calculate_mean(1, 2, 3)
-        except Exception as e:
-            self.fail(f"Fehler bei der Syntax: {e}")
-
-    def test_function_exists(self):
-        self.assertIsNotNone(calculate_mean)
-
-    def test_no_numbers(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_one_number(self):
-        self.assertEqual(calculate_mean([1]), 1)
-
-    def test_multiple_numbers(self):
-        self.assertAlmostEqual(calculate_mean([1, 2, 3]), 2.0)
-
-    def test_string_in_list(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 1, 2])
-
-    def test_non_numeric_value(self):
-        with self.assertRaises(ValueError):
-            calculate_mean([1, 'b', 3])
-
-    def test_zero_length(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_all_strings(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b', 'c'])
-
-    def test_all_floats(self):
-        self.assertAlmostEqual(calculate_mean([1.0, 2.5, 3.8]), 2.5)
-
-    def test_mixed_types(self):
-        with self.assertRaises(ValueError):
-            calculate_mean([1, 'a', 2.0, 3])
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste mit einer sehr großen Zahl ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Teilweise ungenaue Testfälle
-
-**Punkte: 4/10**
-
-***Total: 16/30***
diff --git a/appx/poc_nutzerbefragung.md b/appx/poc_nutzerbefragung.md
deleted file mode 100644
index 292d1783e2f34c617ea3d7c421c359cfaaf12906..0000000000000000000000000000000000000000
--- a/appx/poc_nutzerbefragung.md
+++ /dev/null
@@ -1,182 +0,0 @@
-### **Proof Of Concept Nutzerbefragung**
-
-## **Auswertungstabelle**
-
-| **Proband 1** | **Proband 2** | **Proband 3** | **Proband 4** | **Proband 5** | **Proband 6** |
-|---------------|---------------|---------------|---------------|---------------|---------------|
-| 4             | 1             | 4             | 4             | 4             | 5             |
-| 3             | 1             | 4             | 3             | 4             | 3             |
-| 3             | 1             | 5             | 3             | 4             | 4             |
-| 4             | 1             | 4             | 5             | 5             | 4             |
-| 4             | 1             | 4             | 4             | 4             | 4             |
-
----
-
-## **Einleitungstext**
-ArTEMiS-Tests Fragebogen
-Dieser Fragebogen dient dazu, die Benutzerfreundlichkeit und Qualität der von einer KI entwickelten Tests für Python-Programmieraufgaben in der ArTEMiS-Lernumgebung zu bewerten. Bitte lies dir die unten stehenden Tasks durch und bearbeitet anschließend die entsprechenden Aufgaben in der ArTEMiS-Lernumgebung. Achtet dabei besonders auf das Feedback der bereitgestellten Tests und nimm dir anschließend kurz Zeit, die Fragen zu beantworten.
-
-Vielen Dank für dein Feedback – es hilft, die Qualität der Tests weiter zu verbessern!
-
---- 
-
-## **Aufgaben der Teilnehmenden**
-
-Tasks
-1. Bearbeite die Aufgabe 1: ‘Listenlänge berechnen’, versuche dabei zunächst einen Fehler auszulösen und orientiere dich anschließend an dem Testfeedback, um eine vollständige Lösung zu entwickeln.
-
-2. Bearbeite die Aufgabe 2: ‘Listenausgabe’ versuche dabei zunächst alle Existenztests abzudecken und anschließend nacheinander die Tests der rekursiven und der iterativen Funktion zu erfüllen.
-
-3. (Optional) Löse die Aufgabe 3: ‘Rechtecks Umfang Berechnung’ und überprüfe mithilfe der Tests dein Ergebnis.
-
----
-
-## **Frage 1**
-
-**Hattest du das Gefühl, dass die Tests hilfreich waren?**
-
-Antwortoptionen:
-1 Überhaupt nicht hilfreich
-2 Wenig hilfreich
-3 Neutral
-4 Hilfreich
-5 Sehr hilfreich
-
-Proband 1: 4
-Proband 2: 1
-Proband 3: 4
-Proband 4: 4
-Proband 5: 4
-Proband 6: 5
-
----
-
-## **Frage 2**
-
-**Wie verständlich war das Feedback der Tests formuliert?**
-
-Antwortoptionen:
-1 Überhaupt nicht verständlich
-2 Wenig verständlich
-3 Neutral
-4 Verständlich
-5 vollkommen verständlich
-
-Proband 1: 3
-Proband 2: 1
-Proband 3: 4
-Proband 4: 3
-Proband 5: 4
-Proband 6: 3
-
----
-
-## **Frage 3**
-
-**Konntest du das Feedback nutzen, um deine Lösung zu verbessern?**
-
-Antwortoptionen:
-1 Überhaupt nicht nutzbar
-2 Wenig nutzbar
-3 Neutral
-4 Gut nutzbar
-5 Sehr gut nutzbar
-
-Proband 1: 3
-Proband 2: 1
-Proband 3: 5
-Proband 4: 3
-Proband 5: 4
-Proband 6: 4
-
----
-
-## **Frage 4**
-
-**Wie gut deckten die Tests die Anforderungen der Aufgabe ab?**
-
-Antwortoptionen:
-1 Überhaupt nicht
-2 Kaum
-3 Teilweise
-4 Größtenteils
-5 Vollständig
-
-Proband 1: 4
-Proband 2: 1
-Proband 3: 4
-Proband 4: 5
-Proband 5: 5
-Proband 6: 4
-
----
-
-## **Frage 5**
-
-**Wie zufrieden bist du mit den Tests insgesamt?**
-
-Antwortoptionen:
-1 Überhaupt nicht zufrieden
-2 Wenig zufrieden
-3 Neutral
-4 Zufrieden
-5 Sehr zufrieden
-
-Proband 1: 4
-Proband 2: 1
-Proband 3: 4
-Proband 4: 4
-Proband 5: 4
-Proband 6: 4
-
----
-
-## **Frage 6**
-
-**Was hat dir an den Tests besonders gut gefallen?**
-
-Freitextfeld:
-
-Proband 1: 
--
-Proband 2: 
-- Kleine Aufgaben, bei den man einfach ausprobieren kann
-- Regt zum Ausprobieren an
-Proband 3: 
--Die kürze der Aufgaben
--Das Feedback umzusetzen
--Die einfachen Möglichkeiten z.B. mit Chatgpt diese Aufgaben zu lösen.
--Übersichtlichkeit der Aufgabenstellungen
-Proband 4: 	
-Die Tests waren vor allem in den ersten beiden Aufgaben sehr präzise formuliert und haben mir dabei geholfen, die Aufgaben effektiv zu lösen sowie effizient die fehlerhaften Stellen in meinem Code aufzuspüren.
-Proband 5: 
-Einfacher Satz und nicht lang/kompliziert
-Proband 6: 
--
-
----
-
-## **Frage 7**
-
-**Welche Verbesserungsvorschläge hast du für die Tests?**
-
-Freitextfeld:
-
-Proband 1: 
--
-Proband 2: 
-- Für komplette Anfänger nicht geeignet
-- Ich konnte mit den Aufgaben und daher mit den Hinweisen nichts anfangen
-- Ohne das nötige Hintergrundwissen kommt man nicht weiter
-- Vorher Erklärungen der Aufgaben und der Funktionen (was bedeutet das Ganze?)
-- z.B. Video Tutorials oder ähnliches als Einstieg
-Proband 3: 
--Fehlercodes verbessert darstellen
--Genauer hervorheben, an welcher Stelle der Fehler ist
--Übersichtlichkeit der Hilfestellungen und Zugänglichkeit der Informationen zur Lösung des Problemes
-Proband 4: 
-Vor allem in der letzten Aufgabe fehlten mir Tests in Bezug auf die verwendeten Datentypen. Zudem empfand ich die Formulierung der Tests teilweise als unverständlich/undurchsichtig und ich konnte mit den angegebenen Fehlermeldungen nicht viel anfangen.
-Proband 5: 
-Die entscheidenen Stellen habe ich nicht gleich gesehen. Vielleicht kann der Testcode außenrum weg.
-Proband 6: 
-Hab sie nicht immer gleich verstanden.
diff --git a/appx/promptuntersuchung.md b/appx/promptuntersuchung.md
deleted file mode 100644
index f3a1e376242c7b2b496f22bbc8236e81d05e5de7..0000000000000000000000000000000000000000
--- a/appx/promptuntersuchung.md
+++ /dev/null
@@ -1,1894 +0,0 @@
-# **Promptuntersuchung**
-
-In dieser Analyse werden verschiedene **Prompting-Techniken** systematisch untersucht. Zu jeder Technik wurde ein spezifischer Prompt entwickelt und optimiert, um ein Testskript für den unten stehenden **Code** zu generieren. Jeder Prompt wurde dreimal mit **Llama3** ausgeführt, und die Ergebnisse flossen in die Untersuchung ein.
-
-Die Ausgaben wurden mit einer vordefinierten Liste von **Standard-Testfällen** abgeglichen, bewertet und in ein Punktesystem überführt. Abschließend sind die Ergebnisse in einer **Auswertungstabelle** zusammengefasst, die der Übersichtlichkeit halber am Anfang des Dokuments platziert wurde.
-
----
-
-## **Auswertungstabelle**
-
-| **Technik**           | **Iteration 1** | **Iteration 2** | **Iteration 3** | **Total** | **Prozent** |
-|-----------------------|------------|------------|------------|-----------|-------------|
-| **Instruction-Prompting** | 5/10       | 6/10       | 7/10       | 18/30     | 60,00%      |
-| **Zero-Shot-Prompting**   | 2/10       | 2/10       | 5/10       | 9/30      | 30,00%      |
-| **One-Shot-Prompting**    | 7/10       | 7/10       | 7/10       | 21/30     | 70,00%      |
-| **Few-Shot-Prompting**    | 7/10       | 7/10       | 6/10       | 20/30     | 66,67%      |
-| **Chain-of-Thought-Prompting** | 4/10       | 5/10       | 3/10       | 11/30     | 36,67%      |
-| **Multitask-Prompting**   | 4/10       | 5/10       | 6/10       | 12/30     | 40,00%      |
-| **Instruction + One-Shot Prompting** | 8/10       | 9/10       | 6/10       | 23/30     | 76,67%      |
-
----
-
-## **Code**
-
-```
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-## **Prompting-Techniken**
-1. Instruction-Prompting
-2. Zero-Shot-Prompting
-3. One-Shot-Prompting
-4. Few-Shot-Prompting
-5. Chain of Thought Prompting
-6. Multitask-Prompting
-7. Inscruction-Prompting + One-Shot Prompting
-
----
-
-## **Instruction-Prompting**
-
-```
-You are a Python test generation tool. **Generate a comprehensive Python test suite for the provided code.** Follow these requirements:
-
-- Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-- Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-- Output only the complete Python test suite without any additional explanations or comments.
-
-### Code to Test ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-```
-import unittest
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean_empty_list(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_calculate_mean_single_element(self):
-        self.assertEqual(calculate_mean([5]), 5)
-
-    def test_calculate_mean_multiple_elements(self):
-        self.assertAlmostEqual(calculate_mean([1,2,3,4,5]), 3)
-
-    def test_calculate_mean_mixed_type_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b', 1, 2])
-
-    def test_calculate_mean_non_numeric_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean([1, 2, 'a'])
-
-    def test_calculate_mean_string_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b'])
-
-    def test_calculate_mean_zero_length_list(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_calculate_mean_negative_numbers(self):
-        self.assertAlmostEqual(calculate_mean([-1, 0, 1]), 0)
-
-    def test_calculate_mean_float_input(self):
-        self.assertAlmostEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-```
-import unittest
-from your_module import calculate_mean
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean_empty_list(self):
-        result = calculate_mean([])
-        self.assertEqual(result, None)
-
-    def test_calculate_mean_single_element(self):
-        result = calculate_mean([5])
-        self.assertAlmostEqual(result, 5.0)
-
-    def test_calculate_mean_multiple_elements(self):
-        result = calculate_mean([1, 2, 3, 4, 5])
-        self.assertAlmostEqual(result, 3.0)
-
-    def test_calculate_mean_mixed_type(self):
-        result = calculate_mean([1, "a", 3, None, 5])
-        self.assertEqual(result, 3.0)
-
-    def test_calculate_mean_non_numeric(self):
-        with self.assertRaises(TypeError):
-            calculate_mean([1, "a", 3, [4], 5])
-
-    def test_calculate_mean_zero_length_list(self):
-        result = calculate_mean([])
-        self.assertEqual(result, None)
-
-    def test_calculate_mean_negative_numbers(self):
-        result = calculate_mean([-1, -2, -3])
-        self.assertAlmostEqual(result, -2.0)
-
-    def test_calculate_mean_decimal_numbers(self):
-        result = calculate_mean([1.5, 2.75, 3.25])
-        self.assertAlmostEqual(result, 2.5)
-
-    def test_calculate_mean_negative_and_positive_numbers(self):
-        result = calculate_mean([-1, -2, 0, 1, 2])
-        self.assertAlmostEqual(result, 0.0)
-
-    def test_calculate_mean_no_numeric_elements(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(["a", "b", None])
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 6/10**
-
----
-
-3. ###
-```
-import unittest
-from your_module import calculate_mean  # Replace with actual module name
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean_valid_input(self):
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0)
-
-    def test_calculate_mean_empty_list(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_calculate_mean_non_numeric_values(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b'])
-
-    def test_calculate_mean_mixed_type_list(self):
-        self.assertEqual(calculate_mean([1, 2.5, 3]), 2.1666666666666665)
-
-    def test_calculate_mean_single_numeric_value(self):
-        self.assertEqual(calculate_mean([4]), 4)
-
-    def test_calculate_mean_multiple_numeric_values(self):
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0)
-
-    def test_calculate_mean_negative_and_positive_values(self):
-        self.assertAlmostEqual(calculate_mean([-5, 0, 5]), 0.0)
-
-    def test_calculate_mean_non_integer_division(self):
-        self.assertAlmostEqual(calculate_mean([1.0, 2.0, 3.0]), 2.0)
-
-    def test_calculate_mean_float_input(self):
-        self.assertAlmostEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 7/10**
-
-***Total: 18/30***
-
----
-
-## **Zero-Shot-Prompting**
-
-```
-You are a Python test generation tool. **Generate a Python test suite for the provided code** with German feedback for any failed tests. Use the following structure as a model.
-
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-Here is a Python test suite for the provided code, with German feedback 
-for any failed tests:
-
-```Python
-import unittest
-from your_module import calculate_mean  # Replace 'your_module' with the 
-actual module name
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_empty_list(self):
-        """
-        Eine leere Liste sollte None zurückgeben.
-        :return:
-        """
-        self.assertEqual(calculate_mean([]), None)
-
-    def test_single_element_list(self):
-        """
-        Eine Liste mit einem Element sollte den Durchschnitt des Elements selbst zurückgeben.
-        :return:
-        """
-        self.assertAlmostEqual(calculate_mean([5]), 5.0)
-
-    def test_multiple_elements(self):
-        """
-        Eine Liste mit verschiedenen ganzen Zahlen sollte den Durchschnitt der Zahlen zurückgeben.
-        :return:
-        """
-        self.assertAlmostEqual(calculate_mean([1, 2, 3, 4, 5]), 3.0)
-
-    def test_mixed_types(self):
-        """
-        Eine Liste mit ganzen und floating-point-Zahlen sollte den Durchschnitt der Zahlen zurückgeben.
-        :return:
-        """
-        self.assertAlmostEqual(calculate_mean([1, 2.0, 3, 4.5]), 2.75)
-
-    def test_non_numeric_types(self):
-        """
-        Eine Liste mit nicht-numerischen Elementen sollte None zurückgeben.
-        :return:
-        """
-        self.assertEqual(calculate_mean(["a", "b", "c"]), None)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-This test suite covers the following scenarios:
-
-- An empty list, which should return `None`.
-- A single-element list, which should return the value of that element.
-- A list with multiple elements, where all values are integers or floats, 
-and the average is calculated correctly.
-- A mixed list with both integers and floats, where the average is 
-calculated correctly.
-- A list with non-numeric elements, where `None` is returned.
-
-The tests use `assertEqual` for exact equality and `assertAlmostEqual` for 
-approximate floating-point comparisons. The German feedback comments are 
-provided in docstrings for each test method.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 2/10**
-
----
-
-Here is a test suite for the provided code with German feedback for any 
-failed tests:
-
-```
-import unittest
-from your_module import calculate_mean  # replace 'your_module' with the 
-actual module name
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_empty_list(self):
-        result = calculate_mean([])
-        self.assertIsNone(result, "Fehler bei leeren Listen: Die Funktion sollte None zurückgeben")
-
-    def test_single_element(self):
-        result = calculate_mean([5])
-        self.assertEqual(result, 5.0, "Fehler bei einer Einzelelement-Liste: Die Funktion sollte den Wert 5.0 zurückgeben")
-
-    def test_multiple_elements(self):
-        result = calculate_mean([1, 2, 3, 4, 5])
-        self.assertAlmostEqual(result, 3.0, places=10, msg="Fehler bei mehreren Elementen: Die Funktion sollte den Durchschnitt von 3.0 zurückgeben")
-
-    def test_non_numeric_elements(self):
-        result = calculate_mean(['a', 'b', 'c'])
-        self.assertIsNone(result, "Fehler bei nicht-numericen Elementen: Die Funktion sollte None zurückgeben")
-
-    def test_mixed_type_elements(self):
-        result = calculate_mean([1, 2.0, 3, 4.5])
-        self.assertAlmostEqual(result, 2.5, places=10, msg="Fehler bei gemischten Typ-Elementen: Die Funktion sollte den Durchschnitt von 2.5 zurückgeben")
-
-    def test_division_by_zero(self):
-        result = calculate_mean([1, 2, 3])
-        self.assertIsNone(result, "Fehler bei Division durch Null: Die Funktion sollte None zurückgeben")
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-In this test suite, we're testing the following scenarios:
-
-* An empty list
-* A single element list
-* A list with multiple numeric elements
-* A list with non-numeric elements (e.g., strings)
-* A list with mixed-type elements (e.g., integers and floats)
-* A list where division by zero would occur
-
-For each test, we're checking the expected output using assert methods 
-provided by the unittest module. If a test fails, it will print an error 
-message in German, indicating what went wrong.
-
-Please replace `'your_module'` with the actual name of your Python module 
-that contains the `calculate_mean` function.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ❌
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 2/10**
-
----
-
-Here is a Python test suite for the provided code:
-
-```Python
-import unittest
-from calculate_mean import calculate_mean
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean_with_integers(self):
-        # Positive integers
-        self.assertEqual(calculate_mean([1, 2, 3, 4, 5]), 3.0)
-        
-        # Negative integers
-        self.assertEqual(calculate_mean([-1, -2, -3, -4, -5]), -3.0)
-
-    def test_calculate_mean_with_floats(self):
-        # Positive floats
-        self.assertAlmostEqual(calculate_mean([0.5, 1.25, 2.75, 3.5, 4.25]), 2.375)
-        
-        # Negative floats
-        self.assertAlmostEqual(calculate_mean([-0.5, -1.25, -2.75, -3.5, -4.25]), -2.375)
-
-    def test_calculate_mean_with_mixed_numbers(self):
-        self.assertEqual(calculate_mean([1, 2.5, 3, 4.5, 5]), 3.0)
-        
-    def test_calculate_mean_empty_list(self):
-        self.assertIsNone(calculate_mean([]))
-
-    def test_calculate_mean_non_numeric_values(self):
-        # Integers and floats
-        with self.assertRaises(TypeError):
-            calculate_mean([1, 2, 'a', 4, 5])
-
-        # Non-numeric values only
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b', 'c'])
-
-    def test_calculate_mean_with_single_value(self):
-        self.assertEqual(calculate_mean([42]), 42.0)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-These tests cover various scenarios, including:
-
-1. Positive and negative integers
-2. Positive and negative floats
-3. Mixed numbers (integers and floats)
-4. Empty list
-5. Non-numeric values
-6. Single value
-
-Note: The `assertAlmostEqual` function is used to compare floating-point 
-numbers with a small margin of error, as the actual result may not be 
-exactly equal due to floating-point precision.
-
-In case any test fails, you will receive German feedback like this:
-```
-Fehler in Test 'test_calculate_mean_with_integers': 
-Stimme: 1
-Erwartetes Ergebnis: <Expected>
-Aktuelles Ergebnis: <Actual>
-
-Fehlertext:
-
-AssertionError: assertEqual expected: 3.0, actual: 2.5
-
-In Zeile: 9 in TestCalculateMean
-```
-Translation:
-"Error in test 'test_calculate_mean_with_integers': 
-Value: 1
-Expected result: <Expected>
-Actual result: <Actual>
-
-Error message:
-
-AssertionError: assertEqual expected: 3.0, actual: 2.5
-
-In line: 9 in TestCalculateMean"
-
-This feedback helps you identify which test failed and what the expected 
-and actual results were, making it easier to debug your code.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
-***Total: 9/30***
-
----
-
-## **One-Shot-Prompting**
-
-```
-You are a Python test generation tool. **Generate a Python test suite for the provided code** with German feedback for any failed tests. Use the following structure as a model.
-### Example ###
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(add), "Erstelle eine Funktion mit dem namen 'add'.")
-
-    def test_behavior(self):
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können.")
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können.")
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können.")
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazaheln umgehen können.")
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer ganzen und einer Kommazahl umgehen können.")
-    
-    def test_edge_cases(self):
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können.")
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'add' soll für String Eingaben einen Typfehler werfen."):
-            add("a", 1)
-        with self.assertRaises(TypeError, msg="'add' soll für 'None' Eingaben einen Typfehler werfen."):
-            add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-Here's an example of how you can write tests using the provided structure:
-
-```Python
-import unittest
-from your_module import calculate_mean  # Import the function to be tested
-
-class TestCalculateMean(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Die Funktion 'calculate_mean' existiert nicht.")
-
-    def test_behavior(self):
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' sollte eine leere Liste auf None setzen.")
-        self.assertEqual(calculate_mean([1]), 1, "'calculate_mean' sollte eine Liste mit einem Element auf das Element setzen.")
-        self.assertEqual(calculate_mean([-2, 3, 5]), 2.0, "'calculate_mean' soll eine Mischung von positiven und negativen Zahlen verarbeiten können.")
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'calculate_mean' soll mit Kommazahlen umgehen können.")
-    
-    def test_edge_cases(self):
-        self.assertIsNone(calculate_mean([0]), None, "'calculate_mean' sollte eine Liste mit einem Null-Element auf None setzen.")
-        self.assertEqual(calculate_mean([float('inf'), 1]), float('inf'), "'calculate_mean' soll auch mit großen Zahlen umgehen können.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String Eingaben einen Typfehler werfen."):
-            calculate_mean(["a", 1])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None' Eingaben einen Typfehler werfen."):
-            calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-Please replace `'your_module'` with the name of your module where the 
-`calculate_mean` function is located.
-
-Remember to run these tests after fixing any bugs in your code to ensure 
-that they are working as expected.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ✅
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
----
-
-Here is the test suite for the provided code:
-
-```
-### Test Suite for calculate_mean function ###
-
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Erstelle eine Funktion mit dem Namen 'calculate_mean'.")
-
-    def test_behavior(self):
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll die Mittelwert berechnen.")
-        self.assertIsNone(calculate_mean([]), msg="'calculate_mean' sollte für eine leere Liste None zurückgeben.")
-        self.assertEqual(calculate_mean([-1, -2, 0, 1]), -1/2, "'calculate_mean' soll negative Zahlen addieren können.")
-        self.assertAlmostEqual(calculate_mean([1.5, 2.5]), 2.0, places=1, msg="'calculate_mean' sollte mit Kommazahlen umgehen können.")
-    
-    def test_edge_cases(self):
-        self.assertEqual(calculate_mean([0]), 0, "'calculate_mean' soll für eine Liste mit '0' den '0' als Mittelwert zurückgeben.")
-        self.assertIsNone(calculate_mean([float('inf')]), msg="'calculate_mean' sollte auch mit großen Zahlen umgehen können.")
-    
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String Eingaben einen Typfehler werfen."):
-            calculate_mean(["a", 1])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None' Eingaben einen Typfehler werfen."):
-            calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-In this test suite, we have five tests:
-
-- `test_function_exists`: This test checks if the function exists.
-- `test_behavior`: This test checks if the function calculates the mean 
-correctly for different types of input lists (e.g., with positive and 
-negative numbers, with floating point numbers, etc.).
-- `test_edge_cases`: This test checks if the function handles edge cases 
-(e.g., an empty list, a list with only one element) correctly.
-- `test_invalid_types`: This test checks if the function raises a 
-TypeError when it encounters invalid types in the input list (e.g., 
-strings or None).
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
----
-
-Here is the test suite for your code with German feedback:
-
-```Python
-import unittest
-from your_module import calculate_mean  # replace 'your_module' with the 
-actual name of your module/file
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Erstelle eine Funktion mit dem Namen 'calculate_mean'.")
-
-    def test_behavior(self):
-        self.assertIsNone(calculate_mean([]), "Funktion sollte für leere Liste None zurückgeben.")
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll den Durchschnitt von ganzen Zahlen berechnen können.")
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll den Durchschnitt von negativen Zahlen berechnen können.")
-        self.assertEqual(calculate_mean([1, 2, 3.5, 4, 5.5]), 3.2, "'calculate_mean' soll den Durchschnitt von ganzen und Kommazahlen berechnen können.")
-
-    def test_edge_cases(self):
-        self.assertIsNone(calculate_mean([0]), "Funktion sollte für eine Liste mit nur einem Element None zurückgeben.")
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'calculate_mean' soll den Durchschnitt von Kommazahlen berechnen können.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String Eingaben einen Typfehler werfen."):
-            calculate_mean(["a", 1])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None' Eingaben einen Typfehler werfen."):
-            calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-Replace `'your_module'` with the actual name of your module/file. The test 
-suite includes tests for the existence of the function, its behavior on 
-different types of inputs, edge cases and invalid types.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
-***Total: 21/30**
-
----
-
-## **Few-Shot Prompting**
-
-```
-You are a Python test generation tool. **Generate a Python test suite for the provided code** with German feedback for any failed tests. Use the following structure as a model.
-### Example 1 ###
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(add), "Erstelle eine Funktion mit dem namen 'add'.")
-
-    def test_behavior(self):
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können.")
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können.")
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können.")
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazaheln umgehen können.")
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer ganzen und einer Kommazahl umgehen können.")
-    
-    def test_edge_cases(self):
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können.")
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'add' soll für String Eingaben einen Typfehler werfen."):
-            add("a", 1)
-        with self.assertRaises(TypeError, msg="'add' soll für 'None' Eingaben einen Typfehler werfen."):
-            add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-
-### Example 2 ###
-import unittest
-
-class TestMultiplyFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(multiply), "Erstelle eine Funktion mit dem Namen 'multiply'.")
-
-    def test_behavior(self):
-        self.assertEqual(multiply(2, 3), 6, "'multiply' soll zwei positive Ganzzahlen multiplizieren können.")
-        self.assertEqual(multiply(-2, -3), 6, "'multiply' soll zwei negative Ganzzahlen multiplizieren können.")
-        self.assertEqual(multiply(-2, 3), -6, "'multiply' soll eine negative und eine positive Zahl multiplizieren können.")
-        self.assertEqual(multiply(2.5, 4), 10.0, "'multiply' soll mit Kommazahlen umgehen können.")
-    
-    def test_edge_cases(self):
-        self.assertEqual(multiply(0, 5), 0, "'multiply' soll mit '0' multiplizieren können.")
-        self.assertEqual(multiply(1e10, 2), 2e10, "'multiply' soll auch mit sehr großen Zahlen umgehen können.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'multiply' soll für String Eingaben einen Typfehler werfen."):
-            multiply("a", 1)
-        with self.assertRaises(TypeError, msg="'multiply' soll für 'None' Eingaben einen Typfehler werfen."):
-            multiply(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-
-### Example 3 ###
-import unittest
-
-class TestDivideFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(divide), "Erstelle eine Funktion mit dem Namen 'divide'.")
-
-    def test_behavior(self):
-        self.assertEqual(divide(6, 2), 3, "'divide' soll zwei positive Ganzzahlen korrekt dividieren können.")
-        self.assertEqual(divide(-6, -2), 3, "'divide' soll zwei negative Ganzzahlen korrekt dividieren können.")
-        self.assertEqual(divide(-6, 2), -3, "'divide' soll eine negative und eine positive Zahl korrekt dividieren können.")
-        self.assertAlmostEqual(divide(5, 2), 2.5, "'divide' soll das Ergebnis als Gleitkommazahl zurückgeben, wenn nötig.")
-    
-    def test_edge_cases(self):
-        self.assertEqual(divide(0, 1), 0, "'divide' soll bei einer Division von Null durch eine Zahl Null zurückgeben.")
-        with self.assertRaises(ZeroDivisionError, msg="'divide' soll bei einer Division durch Null einen Fehler auslösen."):
-            divide(1, 0)
-    
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'divide' soll für String-Eingaben einen TypeError auslösen."):
-            divide("a", 2)
-        with self.assertRaises(TypeError, msg="'divide' soll für 'None'-Eingaben einen TypeError auslösen."):
-            divide(None, 2)
-        with self.assertRaises(TypeError, msg="'divide' soll für nicht-numerische Eingaben einen TypeError auslösen."):
-            divide(1, "b")
-
-if __name__ == "__main__":
-    unittest.main()
-
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-Here's a Python test suite using the unittest module:
-
-```Python
-import unittest
-from statistics import mean  # Use the built-in mean function from the 
-statistics module for comparison
-
-class TestCalculateMeanFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Erstelle eine Funktion mit dem Namen 'calculate_mean'.")
-
-    def test_behavior(self):
-        self.assertAlmostEqual(calculate_mean([1, 2, 3]), mean([1, 2, 3]), msg="'calculate_mean' soll die durchschnittliche Zahl berechnen.")
-        self.assertAlmostEqual(calculate_mean([-1, -2, -3]), mean([-1, -2, -3]), msg="'calculate_mean' soll auch negative Zahlen verarbeiten können.")
-        self.assertAlmostEqual(calculate_mean([0.5, 1.5, 2.5]), mean([0.5, 1.5, 2.5]), msg="'calculate_mean' soll auch Kommazahlen verarbeiten können.")
-
-    def test_edge_cases(self):
-        self.assertIsNone(calculate_mean([]), msg="'calculate_mean' soll bei einer leeren Liste None zurückgeben.")
-        self.assertAlmostEqual(calculate_mean([0]), mean([0]), msg="'calculate_mean' soll bei einer Liste mit nur einem Element den Wert dieses Elements zurückgeben.")
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String Eingaben einen TypeError auslösen."):
-            calculate_mean(["a"])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen TypeError auslösen."):
-            calculate_mean([None])
-        
-if __name__ == "__main__":
-    unittest.main()
-```
-This test suite covers the following scenarios:
-- The function exists and can be called.
-- The function calculates the mean correctly for different types of input 
-(integer, negative, floating point).
-- The function handles edge cases like an empty list or a single-element 
-list correctly.
-- The function raises TypeError when given invalid input (like strings or 
-None).
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 7/10**
-
----
-
-Here is the Python test suite for your `calculate_mean` function:
-
-```
-### Code ###
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-    
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Erstelle eine Funktion mit dem Namen 'calculate_mean'.")
-
-    def test_behavior(self):
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll eine Liste von Zahlen korrekt mitteln können.")
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll eine Liste von negativen Zahlen mitteln können.")
-        self.assertEqual(calculate_mean([1, 2, float('inf')]), 1.5, "'calculate_mean' soll auch mit sehr großen Zahlen umgehen können.")
-
-    def test_edge_cases(self):
-        self.assertIsNone(calculate_mean([]), "Die 'calculate_mean' Funktion sollte bei einer leeren Liste None zurückgeben.")
-        self.assertEqual(calculate_mean([0]), 0.0, "'calculate_mean' soll bei einer Liste mit einem Element das element selbst zurückgeben.")
-    
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen TypeError auslösen."):
-            calculate_mean(["a"])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen TypeError auslösen."):
-            calculate_mean([None])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für nicht-numerische Eingaben einen TypeError auslösen."):
-            calculate_mean([1, "b", 3])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
-This test suite checks the following:
-
-*   The function `calculate_mean` exists and is callable.
-*   It tests the basic functionality of calculating the mean with a list 
-of numbers.
-*   It tests edge cases such as an empty list, a list with a single 
-element, or large numbers.
-*   It tests invalid types by passing in strings, None values, and 
-non-numeric values.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-Bemerkungen: 
-- Beinhaltet Fehler
-
-**Punkte: 7/10**
-
----
-
-Here is the generated Python test suite with German feedback for any 
-failed tests:
-```
-### Test Suite ###
-
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        self.assertTrue(callable(calculate_mean), "Erstelle eine Funktion mit dem Namen 'calculate_mean'.")
-
-    def test_behavior(self):
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll die Durchschnittsberechnung korrekt durchführen.")
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll negative Zahlen korrekt berücksichtigen.")
-        self.assertEqual(calculate_mean([1, 2, "a", 4]), None, "'calculate_mean' soll für nicht-numerische Eingaben 'None' zurückgeben.")
-        self.assertAlmostEqual(calculate_mean([0.5, 0.8, 0.9]), 0.7333333333333333, "'calculate_mean' soll die Durchschnittsberechnung korrekt durchführen.")
-
-    def test_edge_cases(self):
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll bei einer leeren Liste 'None' zurückgeben.")
-        self.assertEqual(calculate_mean([1]), 1.0, "'calculate_mean' soll bei einer Liste mit nur einem Element das Element selbst zurückgeben.")
-
-    def test_invalid_types(self):
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen TypeError auslösen."):
-            calculate_mean(["a", "b"])
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen TypeError auslösen."):
-            calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-This test suite checks the following:
-
-* Whether the function `calculate_mean` exists
-* The behavior of the function with different types of input (integer, 
-float, negative numbers)
-* Edge cases (empty list, single-element list)
-* Invalid types (strings, None)
-
-Note that I used the `assertAlmostEqual` method to check the 
-floating-point calculation result. This is because floating-point 
-calculations can sometimes produce slightly inaccurate results due to 
-rounding errors.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/10**
-
-***Total: 20/30***
-
----
-
-## **Chain of Thought Prompting**
-```
-You are a Python test generation tool. Follow each step carefully to **generate a comprehensive test suite for the provided code.**
-
-1. **Verify Class and Function Existence**
-    - Test that each function or class in the code is defined and callable.
-    - Write specific tests to confirm the presence of all essential functions and classes.
-
-2. **Test Expected Behavior**
-    - Design test cases for typical inputs to check if each function performs as intended.
-    - Use a variety of common input values to cover typical use cases.
-
-3. **Include Edge Cases and Special Scenarios**
-    - Add tests for unusual or extreme inputs to assess the function’s stability.
-    - Verify that the function handles these cases correctly and returns the expected output.
-
-4. **Handle Invalid Input Types**
-    - Write test cases for incorrect or unsupported data types passed to the function.
-    - Ensure that the function raises appropriate errors or gracefully handles these inputs.
-
-**Output Requirements**
-    - Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-    - Output only the Python test suite with the defined test cases, without any additional comments or explanations beyond the test code itself.
-
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-Here is the generated test suite for the provided code:
-
-```Python
-import unittest
-from your_module import calculate_mean  # Replace 'your_module' with the actual module name
-
-class TestCalculateMean(unittest.TestCase):
-    def test_function_exists(self):
-        self.assertIsNotNone(calculate_mean)
-
-    def test_empty_list(self):
-        result = calculate_mean([])
-        self.assertEqual(result, None)
-        print("Fehler: Die Funktion sollte für eine leere Liste keinerlei Ausgabe erzeugen. Die Lösung ist die Rückgabe von 'None'.")
-
-    def test_single_integer(self):
-        result = calculate_mean([5])
-        self.assertAlmostEqual(result, 5)
-        print("Funktioniert: Eine einzelne Ganzzahl wird korrekt als Mittelwert zurückgegeben.")
-
-    def test_multiple_integers(self):
-        result = calculate_mean([1, 2, 3, 4, 5])
-        self.assertAlmostEqual(result, 3)
-        print("Funktioniert: Mehrere Ganzzahlen werden korrekt als Mittelwert zurückgegeben.")
-
-    def test_mixed_numbers(self):
-        result = calculate_mean([1, 2.0, 3, 4, 5.0])
-        self.assertAlmostEqual(result, 3)
-        print("Funktioniert: Mischung aus Ganzzahlen und Dezimalzahlen wird korrekt als Mittelwert zurückgegeben.")
-
-    def test_non_numeric_input(self):
-        result = calculate_mean(['a', 'b', 'c'])
-        self.assertEqual(result, None)
-        print("Fehler: Die Funktion sollte für keine nicht-numericen Werte keinerlei Ausgabe erzeugen. Die Lösung ist die Rückgabe von 'None'.")
-
-    def test_non_list_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean('not a list')
-        print("Funktioniert: Die Funktion wirft einen TypeError, wenn ein nicht-Listeingabe gemacht wird.")
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-This test suite includes tests for the existence of the function, edge 
-cases like an empty list or non-numeric inputs, and typical use cases with 
-different types of input data.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
----
-
-Here is the generated test suite:
-
-```
-import unittest
-from your_module import calculate_mean  # Replace 'your_module' with the 
-actual module name
-
-class TestCalculateMean(unittest.TestCase):
-    def test_class_and_function_presence(self):
-        self.assertIsNotNone(calculate_mean)
-        self.assertTrue(callable(calculate_mean))
-
-    def test_typical_input(self):
-        numbers = [1, 2, 3]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 2.0)
-
-    def test_empty_list(self):
-        result = calculate_mean([])
-        self.assertIsNone(result)
-
-    def test_single_element(self):
-        number = 5
-        result = calculate_mean([number])
-        self.assertAlmostEqual(result, number)
-
-    def test_mixed_types(self):
-        numbers = [1, 2.0, 3]
-        result = calculate_mean(numbers)
-        self.assertAlmostEqual(result, 2.0)
-
-    def test_non_numeric_input(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b'])
-
-    def test_invalid_type(self):
-        with self.assertRaises(TypeError):
-            calculate_mean({1: 2})
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-This test suite covers the expected behavior of the `calculate_mean` 
-function, including typical inputs, edge cases, and invalid input types. 
-The output will indicate whether each test passes or fails, with German 
-feedback for failed tests specifying what functionality is required to 
-pass.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Beinhaltet Fehler
-
-**Punkte: 4/10**
-
----
-
-Here is the comprehensive test suite for the provided code:
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_class_definition(self):
-        from calculator import calculate_mean  # assume calculator.py contains the function
-
-    def test_function_callable(self):
-        from calculator import calculate_mean
-        calculate_mean([])
-
-    def test_empty_list_return_none(self):
-        from calculator import calculate_mean
-        self.assertEqual(calculate_mean([]), None)
-
-    def test_single_integer_element(self):
-        from calculator import calculate_mean
-        self.assertAlmostEqual(calculate_mean([42]), 42.0)
-
-    def test_multiple_integer_elements(self):
-        from calculator import calculate_mean
-        self.assertAlmostEqual(calculate_mean([1, 2, 3, 4, 5]), 3.0)
-
-    def test_mixed_type_list_invalid_input(self):
-        from calculator import calculate_mean
-        with self.assertRaises(TypeError):
-            calculate_mean([42, 'hello'])
-
-    def test_non_numeric_element_returns_none(self):
-        from calculator import calculate_mean
-        self.assertEqual(calculate_mean([1, 2, None]), None)
-
-    def test_float_elements(self):
-        from calculator import calculate_mean
-        self.assertAlmostEqual(calculate_mean([1.0, 2.5, 3.25]), 2.25)
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 3/10**
-
-***Total: 11/30***
-
----
-
-## **Multitask-Prompting**
-
-```
-You are a Python test generation tool. Your tasks are as follows to **create a comprehensive test suite for the provided code.** Complete each task independently, then combine all results into a single test suite.
-
-# Task 1: Create a Complete List of Test Cases
-**Goal**: Develop a list covering all necessary conditions to ensure the code functions as intended.
-- Include checks for class and function existence, expected behavior for typical inputs, edge cases for unusual inputs, and error-handling tests for cases like type errors.
-
-# Task 2: Write a Complete Test Script
-**Goal**: Implement a test script that covers all test cases from Task 1.
-
-**Output Requirements**
-    - Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-    - Output only the Python test suite with the defined test cases, without any additional comments or explanations beyond the test code itself.
-
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-```
-
----
-
-**Task 1: Create a Complete List of Test Cases**
-
-1. **Typical input test cases**
-	* calculate_mean([1, 2, 3]): returns the correct mean (e.g., 2.0)
-	* calculate_mean([10, 20, 30]): returns the correct mean (e.g., 20.0)
-	* calculate_mean([-5, -10, 15]): returns the correct mean (e.g., 0.0)
-2. **Edge cases**
-	* calculate_mean([]): returns None
-	* calculate_mean([1.5, 3.7]): returns the correct mean (e.g., 2.6)
-	* calculate_mean(['a', 'b', 'c']): returns None
-	* calculate_mean([None, None, None]): returns None
-3. **Error-handling tests**
-	* calculate_mean('not a list'): raises TypeError
-	* calculate_mean({'not': 'a', 'list': 5}): raises TypeError
-
-**Task 2: Write a Complete Test Script**
-
-```python
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-    def test_typical_inputs(self):
-        self.assertAlmostEqual(calculate_mean([1, 2, 3]), 2.0)
-        self.assertAlmostEqual(calculate_mean([10, 20, 30]), 20.0)
-        self.assertAlmostEqual(calculate_mean([-5, -10, 15]), 0.0)
-
-    def test_edge_cases(self):
-        self.assertIsNone(calculate_mean([]))
-        self.assertAlmostEqual(calculate_mean([1.5, 3.7]), 2.6)
-        self.assertIsNone(calculate_mean(['a', 'b', 'c']))
-        self.assertIsNone(calculate_mean([None, None, None]))
-
-    def test_error_handling(self):
-        with self.assertRaises(TypeError):
-            calculate_mean('not a list')
-        with self.assertRaises(TypeError):
-            calculate_mean({'not': 'a', 'list': 5})
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-**Output Requirements**
-
-The output will be the Python test script above, without any additional 
-comments or explanations beyond the test code itself.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 4/10**
-
----
-
-Here are the results of completing each task independently, followed by 
-combining them into a single test suite:
-
-**Task 1: Create a Complete List of Test Cases**
-
-1. Class existence: `calculate_mean` function exists
-2. Typical inputs:
-	* Empty list: `[]`
-	* Single integer: `[42]`
-	* Single float: `[3.14]`
-	* Mixed integers and floats: `[1, 2, 3.5, 4, 5.7]`
-3. Edge cases:
-	* List with non-numeric elements: `['a', 'b', 3]`
-	* List with mixed numeric and non-numeric elements: `[1, 'c', 2.5, None]`
-	* List with negative numbers: `[-1, -2, -3.4]`
-	* List with zero: `[0, 0, 0]`
-4. Error-handling tests:
-	* Type error (non-list input): `calculate_mean('not a list')`
-	* Value error (invalid type in the list): `calculate_mean([1, 'two', 
-3.5])`
-
-**Task 2: Write a Complete Test Script**
-
-```
-import unittest
-from your_module import calculate_mean
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean_empty_list(self):
-        self.assertEqual(calculate_mean([]), None)
-
-    def test_calculate_mean_single_integer(self):
-        self.assertAlmostEqual(calculate_mean([42]), 42.0)
-
-    def test_calculate_mean_single_float(self):
-        self.assertAlmostEqual(ccalculate_mean([3.14]), 3.14)
-
-    def test_calculate_mean_mixed_int_float(self):
-        self.assertAlmostEqual(calculate_mean([1, 2, 3.5, 4, 5.7]), 3.1)
-
-    def test_calculate_mean_non_numeric_elements(self):
-        with self.assertRaises(TypeError):
-            calculate_mean(['a', 'b', 3])
-
-    def test_calculate_mean_mixed_types(self):
-        with self.assertRaises(TypeError):
-            calculate_mean([1, 'c', 2.5, None])
-
-    def test_calculate_mean_negative_numbers(self):
-        self.assertAlmostEqual(calculate_mean([-1, -2, -3.4]), -2.233333)
-
-    def test_calculate_mean_zero(self):
-        self.assertEqual(calculate_mean([0, 0, 0]), 0.0)
-
-    def test_calculate_mean_type_error(self):
-        with self.assertRaises(TypeError):
-            calculate_mean('not a list')
-
-if __name__ == '__main__':
-    unittest.main()
-```
-
-**Output Requirements**
-
-The test script will output the results of each test case in German:
-- If a test fails, it will output `Fehler: Expected output X, but got Y.`
-- If all tests pass, it will output nothing (i.e., no output).
-
-Please note that the actual output may vary based on the Python version 
-and environment you're using to run the tests.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-**Punkte: 5/10**
-
----
-
-Here are the results of Tasks 1 and 2:
-
-**Task 1: Create a Complete List of Test Cases**
-
-```
-Test cases for calculate_mean function:
-- Existence check:
-    - class existence (calculate_mean exists as a function)
-    - function existence (calculate_mean can be called)
-- Typical inputs:
-    - single integer value
-    - multiple integer values
-    - single float value
-    - multiple float values
-- Edge cases:
-    - empty list (return None)
-    - list with all integers
-    - list with all floats
-    - list containing both integers and floats
-    - list with non-numerical values (strings, etc.)
-- Error-handling tests:
-    - type error (non-list input)
-    - value error (input is not a number)
-```
-
-**Task 2: Write a Complete Test Script**
-
-```Python
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_calculate_mean(self):
-        self.assertIsNotNone(calculate_mean([1, 2, 3, 4, 5]))
-        self.assertEqual(calculate_mean([1, 2, 3, 4, 5]), 3.0)
-
-        self.assertIsNotNone(calculate_mean([1.0, 2.0, 3.0, 4.0, 5.0]))
-        self.assertEqual(calculate_mean([1.0, 2.0, 3.0, 4.0, 5.0]), 3.0)
-
-        self.assertIsNone(calculate_mean([]))
-        self.assertIsNone(calculate_mean([1, 'a', 2, 3]))
-
-        with self.assertRaises(TypeError):
-            calculate_mean('test')
-
-        with self.assertRaises(ValueError):
-            calculate_mean([1, 2, 3, 'a'])
-
-    if __name__ == '__main__':
-        unittest.main()
-```
-
-This test script includes all the test cases defined in Task 1. It covers 
-existence checks, typical inputs, edge cases, and error-handling tests for 
-the `calculate_mean` function.
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ❌
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ❌
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ❌
-
-Bemerkungen: 
-- Beinhaltet Fehler
-
-**Punkte: 3/10**
-
-## **Total: 12/30**
-
----
-
-## **Instruction + One-Shot Prompting**
-
-
-You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite aligns with the given examples and satisfies all specified requirements:
-
-### Requirements ###
-* Include test cases to verify the existence of all classes and functions, expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.
-* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.
-* Output only the complete Python test suite without any additional explanations or comments.
-
-### Example ###
-```
-import unittest
-
-class TestAddFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'add' existiert.
-        """
-        self.assertTrue(callable(add), "'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_add_two_positive_integers(self):
-        """
-        Prüft, ob 'add' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(1, 2), 3, "'add' soll zwei positive Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert.")
-
-    def test_add_two_negative_integers(self):
-        """
-        Prüft, ob 'add' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(add(-1, -2), -3, "'add' soll zwei negative Ganzzahlen addieren können. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_add_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(add(-2, 3), 1, "'add' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_add_two_floats(self):
-        """
-        Prüft, ob 'add' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 2.5), 4.0, "'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden.")
-
-    def test_add_float_and_integer(self):
-        """
-        Prüft, ob 'add' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(add(1.5, 1), 2.5, "'add' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_add_zero_and_integer(self):
-        """
-        Prüft, ob 'add' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(add(0, 1), 1, "'add' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_add_large_number(self):
-        """
-        Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.
-        """
-        self.assertEqual(add(float('inf'), 1), float('inf'), "'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add("a", 1)
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'add' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'add' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): add(1, None)
-
-if __name__ == "__main__":
-    unittest.main()
-```
-### Code ###
-def calculate_mean(number_list: list):
-    length = len(number_list)
-    if length == 0:
-        return None
-    for l in number_list:
-        if type(l) != int:
-            if type(l) != float:
-                return None
-    summe = sum(number_list)
-    average = summe / length
-    return average
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_with_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit positiven Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1, 2, 3]), 2.0, "'calculate_mean' soll positive Ganzzahlen korrekt berechnen. Überprüfe, ob der Code für einfache Mittelwerte funktioniert.")
-
-    def test_calculate_mean_with_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit negativen Ganzzahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, -2, -3]), -2.0, "'calculate_mean' soll negative Ganzzahlen korrekt berechnen. Vergewissere dich, dass Vorzeichen richtig behandelt werden.")
-
-    def test_calculate_mean_with_mixed_integers(self):
-        """
-        Prüft, ob 'calculate_mean' mit gemischten positiven und negativen Zahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([-1, 0, 1]), 0.0, "'calculate_mean' soll gemischte positive und negative Zahlen korrekt berechnen. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_with_floats(self):
-        """
-        Prüft, ob 'calculate_mean' mit Kommazahlen korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5, 3.5]), 2.5, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt berechnet werden.")
-
-    def test_calculate_mean_with_zero(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt berechnet.
-        """
-        self.assertEqual(calculate_mean([0]), 0.0, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_with_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt berechnet.
-        """
-        self.assertIsNone(calculate_mean([]), "'calculate_mean' soll für leere Listen 'None' zurückgeben. Überprüfe, ob die Eingaben korrekt validiert werden.")
-
-    def test_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-    def test_invalid_type_non_numeric(self):
-        """
-        Prüft, ob 'calculate_mean' bei nicht numerischen Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für nicht numerische Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, "a", 2])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ❌
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-
-**Punkte: 8/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMean(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste als ungültig erkennen. Überprüfe die Rückgabewerte.")
-
-    def test_calculate_mean_single_element(self):
-        """
-        Prüft, ob 'calculate_mean' für Listen mit einem Element korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1]), 1, "'calculate_mean' soll eine Liste mit einem Element addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_positive_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei positive Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei positive Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_two_negative_integers(self):
-        """
-        Prüft, ob 'calculate_mean' zwei negative Ganzzahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-1, -2]), -1.5, "'calculate_mean' soll zwei negative Ganzzahlen addieren können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_positive_and_negative_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine positive und eine negative Zahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([-2, 3]), 0.5, "'calculate_mean' soll eine negative und eine positive Zahl addieren können. Achte darauf, dass Vorzeichen korrekt verarbeitet werden.")
-
-    def test_calculate_mean_two_floats(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Kommazahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 2.5]), 2.0, "'calculate_mean' soll mit Kommazahlen umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_float_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' eine Kommazahl und eine Ganzzahl korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1.5, 1]), 1.25, "'calculate_mean' soll mit einer Kommazahl und einer Ganzzahl umgehen können. Überprüfe die Typenkompatibilität.")
-
-    def test_calculate_mean_zero_and_integer(self):
-        """
-        Prüft, ob 'calculate_mean' die Zahl '0' korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([0, 1]), 0.5, "'calculate_mean' soll mit '0' addieren können. Stelle sicher, dass der Code '0' korrekt behandelt.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ✅
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ✅
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ✅
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 9/10**
-
----
-
-```
-import unittest
-
-class TestCalculateMeanFunction(unittest.TestCase):
-
-    def test_function_exists(self):
-        """
-        Prüft, ob die Funktion 'calculate_mean' existiert.
-        """
-        self.assertTrue(callable(calculate_mean), "'calculate_mean' soll existieren. Vergewissere dich, dass die Funktion definiert ist.")
-
-    def test_calculate_mean_empty_list(self):
-        """
-        Prüft, ob 'calculate_mean' eine leere Liste korrekt mit None zurückgibt.
-        """
-        self.assertEqual(calculate_mean([]), None, "'calculate_mean' soll eine leere Liste mit None zurückgeben. Überprüfe den Code für leerer Listen.")
-
-    def test_calculate_mean_single_value(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit einem Wert korrekt zurückgibt.
-        """
-        self.assertEqual(calculate_mean([5]), 5, "'calculate_mean' soll eine Liste mit einem Wert korrekt zurückgeben. Überprüfe den Code für Listen mit einzelnen Werten.")
-
-    def test_calculate_mean_two_values(self):
-        """
-        Prüft, ob 'calculate_mean' zwei Zahlen korrekt addiert.
-        """
-        self.assertEqual(calculate_mean([1, 2]), 1.5, "'calculate_mean' soll zwei Zahlen korrekt addieren und den Mittelwert berechnen.")
-
-    def test_calculate_mean_mixed_type(self):
-        """
-        Prüft, ob 'calculate_mean' eine Liste mit verschiedenen Typen korrekt behandelt.
-        """
-        self.assertEqual(calculate_mean([1, 2.5, -3]), -0.3333333333333333, "'calculate_mean' soll Listen mit verschiedenen Typen korrekt verarbeiten.")
-
-    def test_calculate_mean_invalid_type_string(self):
-        """
-        Prüft, ob 'calculate_mean' bei String-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean(["a", 1])
-
-    def test_calculate_mean_invalid_type_none(self):
-        """
-        Prüft, ob 'calculate_mean' bei 'None'-Eingaben einen Typfehler auslöst.
-        """
-        with self.assertRaises(TypeError, msg="'calculate_mean' soll für 'None'-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden."): calculate_mean([1, None])
-
-if __name__ == "__main__":
-    unittest.main()
-```
-
----
-
-### **Auswertung**
-1. "calculate_mean" Funkton existiert ✅
-2. Berechnet den Durchschnitt einer Liste von positiven Ganzzahlen ✅
-3. Berechnet den Durchschnitt einer Liste von negativen Ganzzahlen ❌
-4. Berechnet den Durchschnitt einer Liste von positiven und negativen Ganzzahlen ✅
-5. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen ❌
-6. Berechnet den Durchschnitt einer Liste von Gleitkommazahlen und Ganzzahlen ✅
-7. Berechnet den Durchschnitt einer Liste mit 0 ❌
-8. Berechnet den Durchschnitt einer Liste von sehr großen Zahlen ❌
-9. Wirft einen Typfehler für Eingaben die nicht-numerische Listen sind (z.B. Strings oder Integer) ✅
-10. Gibt Sinnvolles Feedback für nichterfüllte Testfälle ✅
-
-**Punkte: 6/10**
-
-***Total: 23/30***
diff --git a/src/__pycache__/ai_generator.cpython-312.pyc b/src/__pycache__/ai_generator.cpython-312.pyc
deleted file mode 100644
index cb4223848c454eb45d0b4140b92eb5f6d46f4f2a..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/ai_generator.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/generator.cpython-312.pyc b/src/__pycache__/generator.cpython-312.pyc
deleted file mode 100644
index ccd9a7f23245a3b87b5d1337d9881da98bcc2676..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/generator.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/generator_manager.cpython-312.pyc b/src/__pycache__/generator_manager.cpython-312.pyc
deleted file mode 100644
index ac40a5de3fed9610e408b564a3a61ea9ec452f1c..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/generator_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/prompt_manager.cpython-312.pyc b/src/__pycache__/prompt_manager.cpython-312.pyc
deleted file mode 100644
index 0b05eb79da3738448e72cd5f62beeeede3e596e3..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/prompt_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/prompts.cpython-312.pyc b/src/__pycache__/prompts.cpython-312.pyc
deleted file mode 100644
index 67962bb96e449e11364e72e3fd51102c61e557b1..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/prompts.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/ui_elements.cpython-312.pyc b/src/__pycache__/ui_elements.cpython-312.pyc
deleted file mode 100644
index 598ca91958851f5440d6ce017cc779e562e63e6a..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/ui_elements.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/ui_main.cpython-312.pyc b/src/__pycache__/ui_main.cpython-312.pyc
deleted file mode 100644
index 52202565ee46b99a07ba8466be5dfa503d38b015..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/ui_main.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/ui_settings.cpython-312.pyc b/src/__pycache__/ui_settings.cpython-312.pyc
deleted file mode 100644
index ca8f83904606c50347b4a8a8ebeec8d217b090d5..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/ui_settings.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/ui_testgenerator.cpython-312.pyc b/src/__pycache__/ui_testgenerator.cpython-312.pyc
deleted file mode 100644
index ce90b5701b36b76a9a346ec3bd04a72f1def6974..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/ui_testgenerator.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/validator.cpython-312.pyc b/src/__pycache__/validator.cpython-312.pyc
deleted file mode 100644
index f8cf4f046c2a201100f9348a13b252c577cc0d8a..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/validator.cpython-312.pyc and /dev/null differ
diff --git a/src/__pycache__/validator_manager.cpython-312.pyc b/src/__pycache__/validator_manager.cpython-312.pyc
deleted file mode 100644
index 4e2215ad9905d620cd611eebbb53be7e5d1f402e..0000000000000000000000000000000000000000
Binary files a/src/__pycache__/validator_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/ui_main.py b/src/ui_main.py
index 8e139f3eb2488f30f75af0b0ee1d372fc984ea93..ebd569367ba6f77ab4d494d60ec077d6a6213184 100644
--- a/src/ui_main.py
+++ b/src/ui_main.py
@@ -76,6 +76,20 @@ class UIMain(tk.Frame):
         self.output_text.pack(fill=tk.BOTH, expand=True)
         self.output_text.insert(tk.END, "Hier erscheint der generierte Testcode.")
 
+        # Tastenkombination zum Markieren
+        self.output_text.bind("<Control-a>", lambda e: (
+            self.output_text.config(state=tk.NORMAL), 
+            self.output_text.tag_add("sel", "1.0", tk.END), 
+            self.output_text.config(state=tk.DISABLED),  
+            "break"
+        ))
+        self.output_text.bind("<Command-a>", lambda e: (
+            self.output_text.config(state=tk.NORMAL), 
+            self.output_text.tag_add("sel", "1.0", tk.END), 
+            self.output_text.config(state=tk.DISABLED),  
+            "break"
+        ))
+
         # --- Buttons ---
         generate_button = tk.Button(
             button_frame,
diff --git a/src/ui_settings.py b/src/ui_settings.py
index 697a9178014cb195cfc9175023359fefa2692be2..d4db378987df2389477d0e7a7c4197e0f08240f3 100644
--- a/src/ui_settings.py
+++ b/src/ui_settings.py
@@ -18,7 +18,45 @@ class UISettings(tk.Frame):
             "expected behavior for typical inputs, edge cases for unusual inputs, and handling "
             "of type errors.\n* Provide clear feedback in German for each failed test, specifying "
             "what functionality is required to pass.\n* Output only the complete Python test suite "
-            "without any additional explanations or comments.\n\n### Example ###\n```\n\n```\n"
+            "without any additional explanations or comments.\n\n### Example ###\n"
+            "```\n"
+            "import unittest\n\n"
+            "class TestFunctionBehavior(unittest.TestCase):\n\n"
+            "    def test_typical_case(self):\n"
+            "        \"\"\"\n"
+            "        Testet die Funktionalität für typische Eingaben.\n"
+            "        \"\"\"\n"
+            "        self.assertEqual(\n"
+            "            function_call(args), expected_result,\n"
+            "            \"Hinweis zum erwarteten Verhalten.\"\n"
+            "        )\n\n"
+            "    def test_edge_case(self):\n"
+            "        \"\"\"\n"
+            "        Testet die Funktionalität für Randfälle.\n"
+            "        \"\"\"\n"
+            "        self.assertEqual(\n"
+            "            function_call(args), expected_result,\n"
+            "            \"Hinweis zur Behandlung von Randfällen.\"\n"
+            "        )\n\n"
+            "    def test_error_handling(self):\n"
+            "        \"\"\"\n"
+            "        Testet die Fehlerbehandlung bei ungültigen Eingaben.\n"
+            "        \"\"\"\n"
+            "        with self.assertRaises(\n"
+            "            ExpectedErrorType,\n"
+            "            msg=\"Hinweis zur erwarteten Fehlerbehandlung.\"\n"
+            "        ):\n"
+            "            function_call(invalid_args)\n\n"
+            "class TestFunctionStructure(unittest.TestCase):\n\n"
+            "    def test_function_existence(self):\n"
+            "        \"\"\"\n"
+            "        Prüft, ob die Funktion existiert.\n"
+            "        \"\"\"\n"
+            "        self.assertTrue(\n"
+            "            callable(function_call),\n"
+            "            \"Hinweis zur Existenz und Definition der Funktion.\"\n"
+            "        )\n"
+            "```\n"
             "### Here comes the code to be tested ###"
         )
 
@@ -167,6 +205,20 @@ class UISettings(tk.Frame):
         self.prompt_text.pack(fill=tk.BOTH, expand=True, pady=5)
         self.prompt_text.insert("1.0", self.initial_prompt)
 
+        # Tastenkombination zum Markieren
+        self.prompt_text.bind("<Control-a>", lambda e: (
+            self.prompt_text.config(state=tk.NORMAL), 
+            self.prompt_text.tag_add("sel", "1.0", tk.END), 
+            self.prompt_text.config(state=tk.DISABLED),  
+            "break"
+        ))
+        self.prompt_text.bind("<Command-a>", lambda e: (
+            self.prompt_text.config(state=tk.NORMAL), 
+            self.prompt_text.tag_add("sel", "1.0", tk.END), 
+            self.prompt_text.config(state=tk.DISABLED),  
+            "break"
+        ))
+
         # --- Buttons ---
         save_prompt_button = tk.Button(
             button_frame,