diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..94c0d568c57dfbf10862b4118049899ae99c6cfe
Binary files /dev/null and b/.DS_Store differ
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..67eebaaee7e16360d78d8ba5f410de06c54e8f32
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) [2024] [Yorick Behme]
+
+Hiermit wird unentgeltlich jeder Person, die eine Kopie der Software und der zugehörigen Dokumentationen (die "Software") erhält, die Erlaubnis erteilt, uneingeschränkt mit der Software zu verfahren, einschließlich ohne Einschränkung des Rechts, sie zu nutzen, kopieren, ändern, zusammenzuführen, zu veröffentlichen, zu verbreiten, unterzulizenzieren und/oder zu verkaufen, und Personen, denen diese Software überlassen wird, diese Rechte zu verschaffen, unter den folgenden Bedingungen:
+
+Der obige Urheberrechtshinweis und dieser Erlaubnishinweis sind in allen Kopien oder wesentlichen Teilen der Software beizufügen.
+
+DIE SOFTWARE WIRD OHNE JEDE AUSDRÜCKLICHE ODER IMPLIZIERTE GARANTIE BEREITGESTELLT, EINSCHLIESSLICH DER GARANTIE DER MARKTFÄHIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR JEGLICHEN ANSPRUCH, SCHADEN ODER SONSTIGE VERPFLICHTUNGEN VERANTWORTLICH, OB AUS EINEM VERTRAG, EINER UNERLAUBTEN HANDLUNG ODER ANDERWEITIG, DIE AUS, AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER VERWENDUNG ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ENTSTEHEN.
\ No newline at end of file
diff --git a/README.md b/README.md
index 6e71d266c2935dd41c190de6e4692c2fb82e363e..2c879345fcecbe17381d291b42782f6c879a449c 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,89 @@
-# BA Yorick Behme
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
+# **ArTEMiS-Testskriptgenerierung**
+
+Diese Python-Anwendung nutzt ein lokal mit Ollama betriebenes **Llama3.1-Modell**, um automatisch Testskripte für vorgegebene Musterlösungen zu erstellen. Die generierten Tests sind speziell für den Einsatz in der **ArTEMiS-Lernumgebung** konzipiert.
+
+Ziel ist es, **Kursentwicklerinnen und -entwickler** zu entlasten, die Erstellung neuer Kurse zu vereinfachen und die Qualität der Kurse durch automatisierte Testskriptgenerierung zu steigern.
+
+Vor jeder Anfrage wird die Eingabe optional auf **syntaktische Korrektheit** und das Vorhandensein von **testbaren Strukturen** überprüft. Anschließend wird die Anfrage mittels eines speziell entwickelten **Kombinations-Prompts** oder einem belibigen **Spezialisierungs-Prompt** an das lokale Llama3.1-Modell übergeben. Das Modell verarbeitet die Anfrage und liefert einen generiertes Testscript zurück.
+
+---
+
+## **Features**
+- **Automatisierte Testskriptgenerierung**: Basierend auf einer Musterlösung werden Testskripte generiert.
+- **ArTEMiS-Integration**: Speziell für den Einsatz in der ArTEMiS-Lernumgebung optimiert.
+- **Flexible Eingaben**: Unterstützt verschiedene Python-Programmieraufgaben.
+- **Lokale Ausführung**: Modell läuft lokal ohne Internetverbindung.
+- **Validierung**: Eingaben werden vor der Verarbeitung überprüft (syntaktische Korrektheit, testbare Strukturen).
+
+---
+
+## **Voraussetzungen**
+- Python **3.10** oder höher (Du kannst Python [hier herunterladen](https://www.python.org/))
+- Installation und Nutzung über das Terminal
+---
+
+## **Installation**
+1. **Terminal öffnen:**
+ Öffne dein Terminal und navigiere zu dem Ordner, in welchem du das Tool ablegen möchtest.
+2. **Ollama installieren:**
+ Installiere Ollama, um das Llama3-Modell lokal auszuführen:
+ ```bash
+ pip install ollama
+ ```
+3. **Llama3-Modell laden:**
+ Lade das Modell lokal herunter:
+ ```bash
+ ollama pull llama3.1:8b
+ ```
+4. **Repository klonen:**
+ Lade das Projekt herunter:
+ ```bash
+ git clone https://git-st.inf.tu-dresden.de/ag-feedbacksysteme/student-projects/ba-yorick-behme.git
+ ```
+5. **Ins Code-Verzeichnis wechseln:**
+ Navigiere in das Hauptverzeichnis des Projekts:
+ ```bash
+ cd ba-yorick-behme/src
+ ```
+5. **Programm starten:**
+ Führe die Anwendung aus:
+ ```bash
+ python3 main.py
+ ```
+
+---
+
+## **Projektstruktur**
+
+```plaintext
+├── appx/
+│ ├── artemis_integration.md
+│ ├── beispiel_optimierung.md
+│ ├── feedback_nutzerbefragung.md
+│ ├── modelfileuntersuchung.md
+│ ├── modellauswertung.md
+│ ├── modelluntersuchung.md
+│ ├── modellvergleich.md
+│ ├── poc_nutzerbefragung.md
+│ └── promptuntersuchung.md
+├── src/
+│ ├── generator_manager.py
+│ ├── main.py
+│ ├── prompt_manager.py
+│ ├── prompts.json
+│ ├── ui_main.py
+│ ├── ui_settings.py
+│ └── validator_manager.py
+├── LICENSE
+└── README.md
```
-cd existing_repo
-git remote add origin https://git-st.inf.tu-dresden.de/ag-feedbacksysteme/student-projects/ba-yorick-behme.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://git-st.inf.tu-dresden.de/ag-feedbacksysteme/student-projects/ba-yorick-behme/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+---
-## License
-For open source projects, say how it is licensed.
+## **Hinweise**
+- **Version:** Diese Anwendung basiert auf Prototyp-Version `version-50`.
+- **Einschränkungen:** Derzeit wird nur Python-Code und nur das Model Llama3.1:8b unterstützt.
+- **Feedback:** Für Fragen, Fehlerberichte oder Vorschläge kannst du ein [Issue](https://git-st.inf.tu-dresden.de/ag-feedbacksysteme/student-projects/ba-yorick-behme/-/issues) erstellen.
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+## **Lizenz**
+Dieses Projekt steht unter der [MIT-Lizenz](./LICENSE). Details dazu findest du in der Datei `LICENSE`.
diff --git a/appx/.DS_Store b/appx/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
Binary files /dev/null and b/appx/.DS_Store differ
diff --git a/appx/artemis_integration.md b/appx/artemis_integration.md
new file mode 100644
index 0000000000000000000000000000000000000000..67810239c6284c1c1c731f47f92d80ae1a0278c5
--- /dev/null
+++ b/appx/artemis_integration.md
@@ -0,0 +1,821 @@
+## **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
new file mode 100644
index 0000000000000000000000000000000000000000..1fa1afb4ccf696a9a9693b4ea9969c86d930363f
--- /dev/null
+++ b/appx/beispiel_optimierung.md
@@ -0,0 +1,764 @@
+## **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
new file mode 100644
index 0000000000000000000000000000000000000000..93938bb866287328a5c1e2c635567ec4269ac3be
--- /dev/null
+++ b/appx/feedback_nuterbefragung.md
@@ -0,0 +1,235 @@
+### **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
new file mode 100644
index 0000000000000000000000000000000000000000..57c04fa5be74eccd34dd2fefc90b96dfb94d68ee
--- /dev/null
+++ b/appx/modelfileuntersuchung.md
@@ -0,0 +1,1527 @@
+# **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
new file mode 100644
index 0000000000000000000000000000000000000000..147bf9315670a57e3c98aa68b293e6cabbcd223f
--- /dev/null
+++ b/appx/modellauswertung.md
@@ -0,0 +1,3288 @@
+# **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
new file mode 100644
index 0000000000000000000000000000000000000000..68c7afd031132ef737371c049c9101fa93125ad1
--- /dev/null
+++ b/appx/modelluntersuchung.md
@@ -0,0 +1,1229 @@
+# **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
new file mode 100644
index 0000000000000000000000000000000000000000..02e3b767ba8129d0cd19f9558542bc3b8dd88a3a
--- /dev/null
+++ b/appx/modellvergleich.md
@@ -0,0 +1,485 @@
+# **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
new file mode 100644
index 0000000000000000000000000000000000000000..292d1783e2f34c617ea3d7c421c359cfaaf12906
--- /dev/null
+++ b/appx/poc_nutzerbefragung.md
@@ -0,0 +1,182 @@
+### **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
new file mode 100644
index 0000000000000000000000000000000000000000..f3a1e376242c7b2b496f22bbc8236e81d05e5de7
--- /dev/null
+++ b/appx/promptuntersuchung.md
@@ -0,0 +1,1894 @@
+# **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
new file mode 100644
index 0000000000000000000000000000000000000000..cb4223848c454eb45d0b4140b92eb5f6d46f4f2a
Binary files /dev/null and b/src/__pycache__/ai_generator.cpython-312.pyc differ
diff --git a/src/__pycache__/generator.cpython-312.pyc b/src/__pycache__/generator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccd9a7f23245a3b87b5d1337d9881da98bcc2676
Binary files /dev/null and b/src/__pycache__/generator.cpython-312.pyc differ
diff --git a/src/__pycache__/generator_manager.cpython-312.pyc b/src/__pycache__/generator_manager.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac40a5de3fed9610e408b564a3a61ea9ec452f1c
Binary files /dev/null and b/src/__pycache__/generator_manager.cpython-312.pyc differ
diff --git a/src/__pycache__/prompt_manager.cpython-312.pyc b/src/__pycache__/prompt_manager.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b05eb79da3738448e72cd5f62beeeede3e596e3
Binary files /dev/null and b/src/__pycache__/prompt_manager.cpython-312.pyc differ
diff --git a/src/__pycache__/prompts.cpython-312.pyc b/src/__pycache__/prompts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67962bb96e449e11364e72e3fd51102c61e557b1
Binary files /dev/null and b/src/__pycache__/prompts.cpython-312.pyc differ
diff --git a/src/__pycache__/ui_elements.cpython-312.pyc b/src/__pycache__/ui_elements.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..598ca91958851f5440d6ce017cc779e562e63e6a
Binary files /dev/null and b/src/__pycache__/ui_elements.cpython-312.pyc differ
diff --git a/src/__pycache__/ui_main.cpython-312.pyc b/src/__pycache__/ui_main.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52202565ee46b99a07ba8466be5dfa503d38b015
Binary files /dev/null and b/src/__pycache__/ui_main.cpython-312.pyc differ
diff --git a/src/__pycache__/ui_settings.cpython-312.pyc b/src/__pycache__/ui_settings.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca8f83904606c50347b4a8a8ebeec8d217b090d5
Binary files /dev/null and b/src/__pycache__/ui_settings.cpython-312.pyc differ
diff --git a/src/__pycache__/ui_testgenerator.cpython-312.pyc b/src/__pycache__/ui_testgenerator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce90b5701b36b76a9a346ec3bd04a72f1def6974
Binary files /dev/null and b/src/__pycache__/ui_testgenerator.cpython-312.pyc differ
diff --git a/src/__pycache__/validator.cpython-312.pyc b/src/__pycache__/validator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8cf4f046c2a201100f9348a13b252c577cc0d8a
Binary files /dev/null and b/src/__pycache__/validator.cpython-312.pyc differ
diff --git a/src/__pycache__/validator_manager.cpython-312.pyc b/src/__pycache__/validator_manager.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e2215ad9905d620cd611eebbb53be7e5d1f402e
Binary files /dev/null and b/src/__pycache__/validator_manager.cpython-312.pyc differ
diff --git a/src/generator_manager.py b/src/generator_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ea383243720dbb6374391863a99274e5e40bf8c
--- /dev/null
+++ b/src/generator_manager.py
@@ -0,0 +1,46 @@
+import subprocess
+import threading
+from tkinter import messagebox
+
+class Generator_Manager:
+ def __init__(self, root):
+ self.root = root
+ self.lock = threading.Lock()
+ self.model_name = "llama3.1:8b"
+ self.is_running = False
+
+ def start_generate(self, prompt, code, model_name, callback=None):
+ """
+ Startet die Generierung des Testskripts basierend auf der eingegebenen Musterlösung.
+ """
+ total_prompt = f"{prompt}\n{code}"
+ thread = threading.Thread(target=self._run_subprocess_generation, args=(total_prompt, model_name, callback), daemon=True)
+ thread.start()
+
+ def _run_subprocess_generation(self, total_prompt, model_name, callback):
+ """
+ Führt den Subprozess aus, um das Testskript zu generieren.
+ """
+ output = None
+ try:
+ result = subprocess.run(
+ ["ollama", "run", model_name],
+ input=total_prompt,
+ capture_output=True,
+ text=True
+ )
+ if result.returncode == 0 and result.stdout:
+ output_split = result.stdout.split("```", 2)
+ if len(output_split) > 2:
+ output = output_split[1].strip()
+ else:
+ messagebox.showinfo("Fehler", "Ein Fehler bei der Generierung ist aufgetreten, bitte versuchen Sie es erneut.")
+ else:
+ error_message = result.stderr.strip() if result.stderr else "Unbekannter Fehler."
+ messagebox.showinfo("Fehler", f"Fehler bei der Verbindung mit dem Modell: {error_message}")
+ except subprocess.SubprocessError as e:
+ messagebox.showinfo("Fehler", f"Fehler bei der Verbindung mit dem Modell: {e}")
+ finally:
+ self.is_running = False
+ if callback:
+ callback(output)
diff --git a/src/main.py b/src/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..78c0f1660156c62aec72808c37c63700c4318b37
--- /dev/null
+++ b/src/main.py
@@ -0,0 +1,53 @@
+import tkinter as tk
+from ui_main import UIMain
+from ui_settings import UISettings
+from generator_manager import Generator_Manager
+from validator_manager import Validator_Manager
+from prompt_manager import Prompt_Manager
+
+
+class Main:
+ def __init__(self, root):
+ self.root = root
+ self.root.title("ArTEMiS-Testskriptgenerator")
+ self.root.geometry("1000x800")
+ self.root.resizable(False, False)
+ self.root.configure(bg="#232323")
+
+ # Initialisiere das TestGeneratorModel
+ self.generator_manager = Generator_Manager(self.root)
+ self.prompt_manager = Prompt_Manager()
+ self.validator_manager = Validator_Manager()
+
+ # Frames initialisieren
+ self.main_frame = UIMain(self, self.show_frame, self.generator_manager, self.prompt_manager, self.validator_manager)
+ self.settings_frame = UISettings(self, self.show_frame, self.prompt_manager, self.validator_manager)
+
+ # Frames ins Grid platzieren
+ self.main_frame.grid(row=0, column=0, sticky="nsew")
+ self.settings_frame.grid(row=0, column=0, sticky="nsew")
+
+ # Root-Layout konfigurieren
+ self.root.grid_rowconfigure(0, weight=1)
+ self.root.grid_columnconfigure(0, weight=1)
+
+ # Standardansicht anzeigen
+ self.show_frame(self.main_frame)
+
+ def show_frame(self, frame):
+ """
+ Blendet den angegebenen Frame ein und versteckt die anderen.
+ """
+ # Alle Frames verstecken
+ self.main_frame.grid_remove()
+ self.settings_frame.grid_remove()
+
+ # Gewünschten Frame anzeigen
+ frame.grid()
+ self.root.update_idletasks()
+
+# Hauptprogramm starten
+if __name__ == "__main__":
+ root = tk.Tk()
+ app = Main(root)
+ root.mainloop()
\ No newline at end of file
diff --git a/src/prompt_manager.py b/src/prompt_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d8ba698de0c9e0e65243c0493ba61f211ddf10c
--- /dev/null
+++ b/src/prompt_manager.py
@@ -0,0 +1,113 @@
+import tkinter as tk
+import json
+import os
+from tkinter import messagebox
+
+class Prompt_Manager:
+ def __init__(self, json_file="prompts.json"):
+ """
+ Initialisiert den PromptsManager und lädt die Prompts aus einer JSON-Datei.
+ """
+ self.json_file = json_file
+ self.prompts = self.load_prompts()
+ self.selected_prompt = tk.StringVar(value="Einfache Funktionen")
+
+ def successful_save_prompt_to_json(self, title, content):
+ """
+ Speichert den erstellten Prompt.
+ """
+
+ # Validierung der Eingaben
+ if not title:
+ messagebox.showerror("Fehler", "Der Titel darf nicht leer sein.")
+ return False
+ if not content:
+ messagebox.showerror("Fehler", "Der Prompt-Inhalt darf nicht leer sein.")
+ return False
+
+ try:
+ # Prüfen, ob der Titel bereits existiert
+ if title in self.prompts:
+ overwrite = messagebox.askyesno(
+ "Titel überschreiben?",
+ f"Der Titel '{title}' existiert bereits. Möchtest du ihn überschreiben?"
+ )
+ if overwrite:
+ self.update_prompt(title, content)
+ self.selected_prompt.set(title)
+ return True
+ else:
+ return False
+ else:
+ # Neuen Prompt hinzufügen
+ self.add_prompt(title, content)
+ self.selected_prompt.set(title)
+ return True
+
+ except ValueError as e:
+ messagebox.showerror("Fehler", str(e))
+ return False
+ except Exception as e:
+ messagebox.showerror("Fehler", f"Ein unerwarteter Fehler ist aufgetreten: {e}")
+ return False
+
+ def load_prompts(self):
+ """
+ Lädt die Prompts aus einer JSON-Datei.
+ """
+ if os.path.exists(self.json_file):
+ with open(self.json_file, "r", encoding="utf-8") as f:
+ return json.load(f)
+ else:
+ # Standard-Prompt, falls keine Datei existiert
+ return {
+ "Einfache Funktionen": {
+ "content": "You are a Python test generation tool. **Generate a detailed and comprehensive Python test suite for the provided code.** Make sure the test suite satisfies all specified requirements:\n\n### Requirements ###\n* 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.\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### Here comes the code to be tested ###"
+ }
+ }
+
+ def save_prompts(self):
+ """
+ Speichert die Prompts in einer JSON-Datei.
+ """
+ with open(self.json_file, "w", encoding="utf-8") as f:
+ json.dump(self.prompts, f, indent=4, ensure_ascii=False)
+
+ def get_all_prompts(self):
+ """Liefert alle Prompts."""
+ return self.prompts
+
+ def add_prompt(self, title, content):
+ """
+ Fügt ein neues Prompt hinzu und speichert es.
+ """
+ if not title.strip():
+ raise ValueError("Der Titel darf nicht leer sein.")
+ if not content.strip():
+ raise ValueError("Der Inhalt darf nicht leer sein.")
+ if title in self.prompts:
+ raise ValueError("Ein Prompt mit diesem Titel existiert bereits.")
+
+ self.prompts[title] = {"content": content}
+ self.save_prompts()
+
+ def delete_prompt(self, title):
+ """
+ Löscht ein vorhandenes Prompt und speichert die Änderungen.
+ """
+ if title not in self.prompts:
+ raise ValueError("Ein Prompt mit diesem Titel existiert nicht.")
+
+ del self.prompts[title]
+ self.save_prompts()
+ self.selected_prompt.set("")
+
+ def update_prompt(self, title, content):
+ """
+ Aktualisiert den Inhalt eines vorhandenen Prompts und speichert die Änderungen.
+ """
+ if title not in self.prompts:
+ raise ValueError("Ein Prompt mit diesem Titel existiert nicht.")
+
+ self.prompts[title]["content"] = content
+ self.save_prompts()
diff --git a/src/prompts.json b/src/prompts.json
new file mode 100644
index 0000000000000000000000000000000000000000..f1f26527d3a69064637b1947e9ac4ba8cfd71545
--- /dev/null
+++ b/src/prompts.json
@@ -0,0 +1,26 @@
+{
+ "Einfache Funktionen": {
+ "content": "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:\n\n### Requirements ###\n* 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.\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```\nimport unittest\nfrom assignment.add import ... # Importiere den zu testenden Code\n\nclass TestAddFunctionBehavior(unittest.TestCase):\n\n def test_add_for_integers(self):\n \"\"\"\n Prüft, ob 'add' zwei integer korrekt addiert.\n \"\"\"\n self.assertEqual(\n add(1, -2), -1,\n \"'add' soll zwei Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert. Hast du sichergestellt, dass der '+'-Operator für Ganzzahlen verwendet wird?\"\n )\n\n def test_add_positive_and_negative_integer(self):\n \"\"\"\n Prüft, ob 'add' eine positive und eine negative Zahl korrekt addiert.\n \"\"\"\n self.assertEqual(\n add(-2, 3), 1,\n \"'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?\"\n )\n\n def test_add_two_floats(self):\n \"\"\"\n Prüft, ob 'add' zwei Kommazahlen korrekt addiert.\n \"\"\"\n self.assertEqual(\n add(1.5, 2.5), 4.0,\n \"'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden. Wird das Ergebnis auf die richtige Genauigkeit geprüft?\"\n )\n\n def test_add_zero_and_integer(self):\n \"\"\"\n Prüft, ob 'add' die Zahl '0' korrekt addiert.\n \"\"\"\n self.assertEqual(\n add(0, 1), 1,\n \"'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?\"\n )\n\n def test_add_large_number(self):\n \"\"\"\n Prüft, ob 'add' mit sehr großen Zahlen umgehen kann.\n \"\"\"\n self.assertEqual(\n add(float('inf'), 1), float('inf'),\n \"'add' soll auch mit großen Zahlen umgehen können. Achte darauf, dass keine Überläufe auftreten. Wie behandelst du Sonderwerte wie 'inf' oder 'NaN'?\"\n )\n\n def test_invalid_type_string(self):\n \"\"\"\n Prüft, ob 'add' bei String-Eingaben einen Typfehler auslöst.\n \"\"\"\n with self.assertRaises(\n TypeError,\n msg=\"'add' soll für String-Eingaben einen Typfehler werfen. Überprüfe, ob die Eingaben korrekt validiert werden. Wird der Typ der Eingabeparameter überprüft?\"\n ):\n add(\"a\", 1)\n\nclass TestAddFunctionStructure(unittest.TestCase):\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Funktion 'add' existiert.\n \"\"\"\n self.assertTrue(\n callable(add),\n \"'add' soll existieren. Vergewissere dich, dass die Funktion definiert ist. Hast du überprüft, ob die Funktion richtig geschrieben wurde?\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Input/Output ohne Funktion": {
+ "content": "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:\n\n### Requirements ###\n* Include test cases to verify the expected behavior for typical inputs, edge cases for unusual inputs, and handling of type errors.\n* Simulate user interaction by mocking inputs and capturing outputs where necessary.\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```\nimport unittest\nfrom unittest.mock import patch\nfrom io import StringIO\nimport importlib\n\nclass TestTemperatureConversionBehavior:\n \"\"\"\n Testklasse für das Verhalten der Temperaturumrechnung.\n \"\"\"\n\n def test_positive_input(self):\n \"\"\"\n Testet die Umrechnung bei einer positiven Celsius-Eingabe.\n \"\"\"\n with patch('builtins.input', return_value='25'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import assignment.temperature_conversion\n importlib.reload(assignment.temperature_conversion)\n output = mock_stdout.getvalue().strip()\n\n # Überprüfe die Ausgabe\n assert \"25.0°C entspricht 77.0°F.\" in output, (\n \"Das Programm sollte positiven Input korrekt berechnen und ausgeben. \"\n \"Hast du überprüft, ob die Umrechnungsformel korrekt implementiert ist?\"\n )\n\n def test_negative_input(self):\n \"\"\"\n Testet die Umrechnung bei einer negativen Celsius-Eingabe.\n \"\"\"\n with patch('builtins.input', return_value='-10'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import assignment.temperature_conversion \n importlib.reload(assignment.temperature_conversion)\n output = mock_stdout.getvalue().strip()\n\n # Überprüfe die Ausgabe\n assert \"-10.0°C entspricht 14.0°F.\" in output, (\n \"Das Programm sollte negativen Input korrekt berechnen und ausgeben. \"\n \"Wird bei negativen Werten die Formel richtig angewendet und die Ausgabe korrekt formatiert?\"\n )\n\n def test_large_input(self):\n \"\"\"\n Testet die Umrechnung bei einer sehr großen Celsius-Eingabe.\n \"\"\"\n with patch('builtins.input', return_value='1000000'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import assignment.temperature_conversion \n importlib.reload(assignment.temperature_conversion)\n output = mock_stdout.getvalue().strip()\n\n # Überprüfe die Ausgabe\n assert \"1000000.0°C entspricht 1800032.0°F.\" in output, (\n \"Das Programm sollte mit großem Input korrekt umgehen. \"\n \"Hast du darauf geachtet, dass der Code keine Fehler bei sehr großen Zahlen wirft?\"\n )\n\n def test_float_input(self):\n \"\"\"\n Testet die Umrechnung bei einer Fließkommazahl als Celsius-Eingabe.\n \"\"\"\n with patch('builtins.input', return_value='37.5'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import assignment.temperature_conversion\n importlib.reload(assignment.temperature_conversion)\n output = mock_stdout.getvalue().strip()\n\n # Überprüfe die Ausgabe\n assert \"37.5°C entspricht 99.5°F.\" in output, (\n \"Das Programm sollte gleitkomma Input korrekt berechnen und ausgeben. \"\n \"Überprüfe, ob die Umrechnung für nicht-ganzzahlige Werte exakt ist.\"\n )\n\n\nclass TestTemperatureConversionStructure:\n \"\"\"\n Testklasse für die Struktur der Temperaturumrechnung.\n \"\"\"\n\n def test_output_contains_correct_phrase(self):\n \"\"\"\n Prüft, ob die Ausgabe die richtige Formulierung enthält.\n \"\"\"\n with patch('builtins.input', return_value='25'), patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import assignment.temperature_conversion\n importlib.reload(assignment.temperature_conversion)\n output = mock_stdout.getvalue().strip()\n\n # Strukturprüfung der Ausgabe\n assert \"°C entspricht\" in output, (\n \"Die Ausgabe sollte den Text '°C entspricht' enthalten. \"\n \"Ist sichergestellt, dass die Ausgabe einheitlich formatiert ist?\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Output ohne Funktion": {
+ "content": "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:\n\n## Requirements\n* Include test cases to verify the expected output for typical inputs, edge cases for unusual inputs, and handling of invalid or unexpected inputs.\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```\nimport unittest\nfrom unittest.mock import patch\nfrom io import StringIO\nfrom assignment.hello_world import ... # Importiere den zu testenden Code\n\nclass TestHelloWorldOutput(unittest.TestCase):\n\n def test_output(self):\n \"\"\"\n Prüft, ob die Ausgabe korrekt 'Hallo Welt' ist.\n \"\"\"\n with patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n import hello_world # Das zu testende Script wird importiert und ausgeführt\n output = mock_stdout.getvalue().strip()\n self.assertEqual(output, \"Hallo Welt\", \n \"Die Ausgabe sollte 'Hallo Welt' sein.\")\n```\n### Here comes the code to be tested ###"
+ },
+ "Iterative Funktion": {
+ "content": "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:\n\n## Requirements\n* Include test cases to verify the existence of the function and its correct implementation using iteration.\n* Test for expected behavior with typical inputs, edge cases for unusual inputs, and invalid inputs.\n* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.\n* Ensure that the implementation avoids recursion and uses iterative constructs (e.g., loops).\n* Output only the complete Python test suite without any additional explanations or comments.\n\n## Example\n```\nimport unittest\nimport inspect\nfrom assignment.iterative_sum import iterative_sum # Ersetze mit der tatsächlichen Datei und Funktion\n\nclass TestIterativeSumBehavior(unittest.TestCase):\n \"\"\"\n Testklasse für das Verhalten der Funktion 'iterative_sum'.\n \"\"\"\n\n def test_sum_of_positive_numbers(self):\n \"\"\"\n Prüft die Korrektheit bei positiven Zahlen.\n \"\"\"\n self.assertEqual(\n iterative_sum(5), \n 15, \n \"'iterative_sum' soll die Summe von positiven Zahlen korrekt berechnen. \"\n \"Hast du sichergestellt, dass alle Zahlen von 1 bis zur Eingabe korrekt addiert werden?\"\n )\n\n def test_sum_of_zero(self):\n \"\"\"\n Prüft die Korrektheit bei der Eingabe 0.\n \"\"\"\n self.assertEqual(\n iterative_sum(0), \n 0, \n \"'iterative_sum' soll die Summe von 0 korrekt berechnen. \"\n \"Wird in deinem Code der Sonderfall für die Eingabe 0 explizit behandelt?\"\n )\n\nclass TestIterativeSumStructure(unittest.TestCase):\n \"\"\"\n Testklasse für die strukturellen Aspekte der Funktion 'iterative_sum'.\n \"\"\"\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Funktion 'iterative_sum' existiert.\n \"\"\"\n self.assertTrue(\n callable(iterative_sum), \n \"'iterative_sum' soll existieren. Vergewissere dich, dass du die Funktion richtig geschrieben hast.\"\n )\n\n def test_is_iterative(self):\n \"\"\"\n Prüft, ob die Funktion 'iterative_sum' iterativ implementiert wurde.\n \"\"\"\n source_code = inspect.getsource(iterative_sum)\n self.assertNotIn(\n \"return iterative_sum\", \n source_code, \n \"'iterative_sum' soll iterativ implementiert sein. Es wurden rekursive Aufrufe gefunden. \"\n \"Hast du überprüft, ob eine Schleife zur Summenberechnung verwendet wird?\"\n )\n self.assertIn(\n \"for\", \n source_code, \n \"'iterative_sum' soll iterativ implementiert sein. Eine Schleife (z. B. 'for') wird erwartet. \"\n \"Überprüfe, ob der Code tatsächlich iterativ arbeitet.\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Rekursive Funktion": {
+ "content": "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:\n\n## Requirements\n* Include test cases to verify the existence of the function and its correct implementation using iteration.\n* Test for expected behavior with typical inputs, edge cases for unusual inputs, and invalid inputs.\n* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.\n* Ensure that the implementation uses recursion and avoids iterative constructs (e.g., loops).\n* Output only the complete Python test suite without any additional explanations or comments.\n\n### Example ###\n\n```\nimport unittest\nimport inspect\nfrom assignment.recursive_sum import recursive_sum # Ersetze mit der tatsächlichen Datei und Funktion\n\nclass TestRecursiveSumBehavior(unittest.TestCase):\n \"\"\"\n Testklasse für das Verhalten der Funktion 'recursive_sum'.\n \"\"\"\n\n def test_sum_of_positive_numbers(self):\n \"\"\"\n Prüft die Korrektheit bei positiven Zahlen.\n \"\"\"\n self.assertEqual(\n recursive_sum(5), \n 15, \n \"'recursive_sum' soll die Summe von positiven Zahlen korrekt berechnen. \"\n \"Hast du überprüft, ob der rekursive Aufruf die Basisbedingungen und die Rekursion korrekt abdeckt?\"\n )\n\n def test_sum_of_zero(self):\n \"\"\"\n Prüft die Korrektheit bei der Eingabe 0.\n \"\"\"\n self.assertEqual(\n recursive_sum(0), \n 0, \n \"'recursive_sum' soll die Summe von 0 korrekt berechnen. \"\n \"Wird der Basisfall für die Eingabe 0 explizit behandelt?\"\n )\n\nclass TestRecursiveSumStructure(unittest.TestCase):\n \"\"\"\n Testklasse für die strukturellen Aspekte der Funktion 'recursive_sum'.\n \"\"\"\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Funktion 'recursive_sum' existiert.\n \"\"\"\n self.assertTrue(\n callable(recursive_sum), \n \"'recursive_sum' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist.\"\n )\n\n def test_is_recursive(self):\n \"\"\"\n Prüft, ob die Funktion 'recursive_sum' rekursiv implementiert wurde.\n \"\"\"\n source_code = inspect.getsource(recursive_sum)\n occurrences = source_code.count(\"recursive_sum(\")\n\n self.assertGreaterEqual(\n occurrences, \n 2, \n \"'recursive_sum' soll rekursiv implementiert sein. Der rekursive Aufruf wurde nicht gefunden. \"\n \"Stelle sicher, dass die Funktion sich selbst korrekt aufruft.\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Iterative Funktion mit Output": {
+ "content": "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:\n\n## Requirements\n* Include test cases to verify the existence of the function and its correct implementation using iteration.\n* Test for expected behavior with typical inputs, edge cases for unusual inputs, and invalid inputs.\n* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.\n* Ensure that the implementation avoids recursion and uses iterative constructs (e.g., loops).\n* Output only the complete Python test suite without any additional explanations or comments.\n\n## Example\n```\nimport unittest\nfrom unittest.mock import patch\nfrom io import StringIO\nfrom assignment.iterative_sum import iterative_sum # Ersetze mit der tatsächlichen Datei und Funktion\n\n\nclass TestIterativeSumBehavior(unittest.TestCase):\n \"\"\"\n Testklasse für das Verhalten der Funktion 'iterative_sum'.\n \"\"\"\n\n def test_sum_of_positive_numbers(self):\n \"\"\"\n Prüft die Ausgabe bei positiven Zahlen.\n \"\"\"\n expected_output = \"1\\n3\\n6\\n10\\n15\\n\" \n with patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n iterative_sum(5)\n self.assertEqual(\n mock_stdout.getvalue(),\n expected_output,\n \"'iterative_sum' soll die Teilsummen korrekt ausgeben. \"\n \"Hast du sichergestellt, dass alle Teilsummen korrekt berechnet und ausgegeben werden?\"\n )\n\n def test_sum_of_zero(self):\n \"\"\"\n Prüft die Ausgabe bei der Eingabe 0.\n \"\"\"\n expected_output = \"0\\n\" \n with patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n iterative_sum(0)\n self.assertEqual(\n mock_stdout.getvalue(),\n expected_output,\n \"'iterative_sum' soll keine Ausgabe machen, wenn 0 eingegeben wird. \"\n \"Wird der Sonderfall für die Eingabe 0 korrekt behandelt?\"\n )\n\nclass TestIterativeSumStructure(unittest.TestCase):\n \"\"\"\n Testklasse für die strukturellen Aspekte der Funktion 'iterative_sum'.\n \"\"\"\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Funktion 'iterative_sum' existiert.\n \"\"\"\n self.assertTrue(\n callable(iterative_sum),\n \"'iterative_sum' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist.\"\n )\n\n def test_is_iterative(self):\n \"\"\"\n Prüft, ob die Funktion 'iterative_sum' iterativ implementiert wurde.\n \"\"\"\n import inspect\n source_code = inspect.getsource(iterative_sum)\n self.assertNotIn(\n \"return iterative_sum\",\n source_code,\n \"'iterative_sum' soll iterativ implementiert sein. Es wurden rekursive Aufrufe gefunden. \"\n \"Hast du überprüft, ob eine Schleife zur Summenberechnung verwendet wird?\"\n )\n self.assertIn(\n \"for\",\n source_code,\n \"'iterative_sum' soll iterativ implementiert sein. Eine Schleife (z. B. 'for') wird erwartet. \"\n \"Überprüfe, ob der Code tatsächlich iterativ arbeitet.\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Rekursive Funktion mit Output": {
+ "content": "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:\n\n## Requirements\n* Include test cases to verify the existence of the function and its correct implementation using iteration.\n* Test for expected behavior with typical inputs, edge cases for unusual inputs, and invalid inputs.\n* Provide clear feedback in German for each failed test, specifying what functionality is required to pass.\n* Ensure that the implementation uses recursion and avoids iterative constructs (e.g., loops).\n* Output only the complete Python test suite without any additional explanations or comments.\n\n### Example ###\n\n```\nimport unittest\nfrom unittest.mock import patch\nfrom io import StringIO\nfrom assignment.recursive_sum import recursive_sum # Ersetze mit der tatsächlichen Datei und Funktion\n\nclass TestRecursiveSumBehavior(unittest.TestCase):\n \"\"\"\n Testklasse für das Verhalten der Funktion 'recursive_sum'.\n \"\"\"\n\n def test_sum_of_positive_numbers(self):\n \"\"\"\n Prüft die Ausgabe bei positiven Zahlen.\n \"\"\"\n expected_output = \"5\\n9\\n12\\n14\\n15\\n\" \n with patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n recursive_sum(5, 0)\n self.assertEqual(\n mock_stdout.getvalue(),\n expected_output,\n \"'recursive_sum' soll die Zwischensummen korrekt ausgeben. \"\n \"Überprüfe, ob die Zwischensummen bei jedem Schritt korrekt berechnet und ausgegeben werden.\"\n )\n\n def test_sum_of_zero(self):\n \"\"\"\n Prüft die Ausgabe bei der Eingabe 0.\n \"\"\"\n expected_output = \"0\\n\" \n with patch('sys.stdout', new_callable=StringIO) as mock_stdout:\n recursive_sum(0, 0)\n self.assertEqual(\n mock_stdout.getvalue(),\n expected_output,\n \"'recursive_sum' soll die Zwischensumme korrekt ausgeben, wenn 0 eingegeben wird. \"\n \"Wird der Basisfall explizit behandelt?\"\n )\n\nclass TestRecursiveSumStructure(unittest.TestCase):\n \"\"\"\n Testklasse für die strukturellen Aspekte der Funktion 'recursive_sum'.\n \"\"\"\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Funktion 'recursive_sum' existiert.\n \"\"\"\n self.assertTrue(\n callable(recursive_sum),\n \"'recursive_sum' soll existieren. Vergewissere dich, dass die Funktion im Modul korrekt definiert ist.\"\n )\n\n def test_is_recursive(self):\n \"\"\"\n Prüft, ob die Funktion 'recursive_sum' rekursiv implementiert wurde.\n \"\"\"\n import inspect\n source_code = inspect.getsource(recursive_sum)\n occurrences = source_code.count(\"recursive_sum(\")\n\n self.assertGreaterEqual(\n occurrences,\n 2,\n \"'recursive_sum' soll rekursiv implementiert sein. Der rekursive Aufruf wurde nicht gefunden. \"\n \"Stelle sicher, dass die Funktion sich selbst korrekt aufruft.\"\n )\n self.assertNotIn(\n \"for\",\n source_code,\n \"'recursive_sum' soll rekursiv implementiert sein. Schleifen (z. B. 'for') sind nicht erlaubt. \"\n \"Falls du eine Schleife verwendest, ersetze sie durch einen rekursiven Aufruf.\"\n )\n self.assertNotIn(\n \"while\",\n source_code,\n \"'recursive_sum' soll rekursiv implementiert sein. Schleifen (z. B. 'while') sind nicht erlaubt. \"\n \"Falls du eine Schleife verwendest, überprüfe, wie sie durch Rekursion ersetzt werden kann.\"\n )\n```\n### Here comes the code to be tested ###"
+ },
+ "Verwendung von Klassen mit einfachen Funktionen": {
+ "content": "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:\n\n### Requirements ###\n* 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.\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```\nimport unittest\nfrom assignment.addition import Addition # Importiere die zu testende Klasse\n\nclass TestAdditionBehavior(unittest.TestCase):\n\n def setUp(self):\n \"\"\"\n Setzt eine Instanz der Addition-Klasse für die Tests.\n \"\"\"\n self.addition = Addition()\n\n def test_add_for_integers(self):\n \"\"\"\n Prüft, ob 'add' zwei integer korrekt addiert.\n \"\"\"\n self.assertEqual(\n self.addition.add(1, -2), -1,\n \"'add' soll zwei Ganzzahlen addieren können. Überprüfe, ob der Code für einfache Summen funktioniert. Hast du sichergestellt, dass der '+'-Operator für Ganzzahlen verwendet wird?\"\n )\n\n def test_add_two_floats(self):\n \"\"\"\n Prüft, ob 'add' zwei Kommazahlen korrekt addiert.\n \"\"\"\n self.assertEqual(\n self.addition.add(1.5, 2.5), 4.0,\n \"'add' soll mit Kommazahlen umgehen können. Überprüfe, ob Fließkommazahlen korrekt summiert werden. Wird das Ergebnis auf die richtige Genauigkeit geprüft?\"\n )\n\n def test_add_zero_and_integer(self):\n \"\"\"\n Prüft, ob 'add' die Zahl '0' korrekt addiert.\n \"\"\"\n self.assertEqual(\n self.addition.add(0, 1), 1,\n \"'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?\"\n )\n\nclass TestAdditionStructure(unittest.TestCase):\n\n def test_class_exists(self):\n \"\"\"\n Prüft, ob die Klasse 'Addition' existiert.\n \"\"\"\n self.assertTrue(\n 'Addition' in globals(),\n \"'Addition' soll existieren. Vergewissere dich, dass die Klasse definiert ist und korrekt geschrieben wurde.\"\n )\n\n def test_function_exists(self):\n \"\"\"\n Prüft, ob die Methode 'add' in der Klasse 'Addition' existiert.\n \"\"\"\n self.assertTrue(\n callable(getattr(Addition, 'add', None)),\n \"'add' soll in der Klasse 'Addition' existieren. Überprüfe, ob die Methode richtig definiert wurde.\"\n )\n\n```\n### Here comes the code to be tested ###"
+ }
+}
\ No newline at end of file
diff --git a/src/ui_main.py b/src/ui_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e139f3eb2488f30f75af0b0ee1d372fc984ea93
--- /dev/null
+++ b/src/ui_main.py
@@ -0,0 +1,160 @@
+import tkinter as tk
+from tkinter import scrolledtext
+
+
+class UIMain(tk.Frame):
+ def __init__(self, main_app, switch_frame_callback, generator_manager, prompt_manager, validator_manager):
+ super().__init__(main_app.root, bg="#E0E0E0")
+ self.main_app = main_app
+
+ self.switch_frame_callback = switch_frame_callback
+ self.generator_manager = generator_manager
+ self.prompt_manager = prompt_manager
+ self.validator_manager = validator_manager
+
+ self.create_widgets()
+
+ def create_widgets(self):
+ """
+ Erstellen der Widgets für die Hauptansicht des Testgenerators.
+ """
+ # Hauptinhaltsbereich
+ content_frame = tk.Frame(self, bg="#E0E0E0", padx=15, pady=15)
+ content_frame.pack(fill=tk.BOTH, expand=True)
+
+ # Eingabe- und Ausgabe-Bereich in zwei Spalten teilen
+ input_frame = tk.Frame(content_frame, bg="#FFFFFF", bd=1, relief="solid", padx=10, pady=10)
+ input_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
+
+ output_frame = tk.Frame(content_frame, bg="#FFFFFF", bd=1, relief="solid", padx=10, pady=10)
+ output_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
+
+ # Rahmen für die Buttons
+ button_frame = tk.Frame(content_frame, bg="#E0E0E0")
+ button_frame.grid(row=1, column=0, columnspan=2, pady=(10, 0))
+
+ # --- Eingabe-Bereich ---
+ tk.Label(
+ input_frame,
+ text="Musterlösung",
+ font=("Arial", 16, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 10))
+
+ self.code_text = scrolledtext.ScrolledText(
+ input_frame,
+ wrap=tk.WORD,
+ font=("Courier New", 12),
+ bg="#F9F9F9",
+ fg="#333333",
+ relief="flat",
+ borderwidth=0,
+ )
+ self.code_text.pack(fill=tk.BOTH, expand=True)
+ self.code_text.insert(
+ tk.END, "Beispiel...\ndef add(a, b):\n return a + b"
+ )
+
+ # --- Ausgabe-Bereich ---
+ tk.Label(
+ output_frame,
+ text="Testskript",
+ font=("Arial", 16, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 10))
+
+ self.output_text = scrolledtext.ScrolledText(
+ output_frame,
+ wrap=tk.WORD,
+ font=("Courier New", 12),
+ bg="#F9F9F9",
+ fg="#333333",
+ state=tk.DISABLED,
+ )
+ self.output_text.pack(fill=tk.BOTH, expand=True)
+ self.output_text.insert(tk.END, "Hier erscheint der generierte Testcode.")
+
+ # --- Buttons ---
+ generate_button = tk.Button(
+ button_frame,
+ text="Test generieren",
+ command=lambda: self.generate_testscript(),
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ highlightcolor="#999999",
+ highlightbackground="#E0E0E0",
+ width=18,
+ height=2,
+ )
+ generate_button.grid(row=0, column=0, padx=5, pady=5)
+
+ settings_button = tk.Button(
+ button_frame,
+ text="Einstellungen",
+ command=lambda: self.switch_frame_callback(self.main_app.settings_frame),
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ highlightcolor="#999999",
+ highlightbackground="#E0E0E0",
+ width=18,
+ height=2,
+ )
+ settings_button.grid(row=0, column=1, padx=5, pady=5)
+
+ # Layout-Management
+ content_frame.grid_columnconfigure(0, weight=1)
+ content_frame.grid_columnconfigure(1, weight=1)
+ content_frame.grid_rowconfigure(0, weight=1)
+
+ def update_output(self, result):
+ """
+ Aktualisiert den Ausgabebereich mit dem generierten Testcode.
+ """
+ self.output_text.config(state=tk.NORMAL)
+ self.output_text.delete("1.0", tk.END)
+ self.output_text.insert(tk.END, result)
+ self.output_text.config(state=tk.DISABLED)
+
+ def generate_testscript(self):
+ """
+ Überprüft die Bedingungen und startet die Testskriptgenerierung.
+ """
+ # Variablen für die Generierung
+ code = self.code_text.get("1.0", tk.END).strip()
+ selected_prompt_title = self.prompt_manager.selected_prompt.get()
+ prompt_content = self.prompt_manager.prompts[selected_prompt_title]["content"]
+ model_name = self.generator_manager.model_name
+ is_running = self.generator_manager.is_running
+ syntax_check = self.validator_manager.syntax_check_option.get()
+ structure_check = self.validator_manager.structure_check_option.get()
+
+ # Bedingungen für die Generierung prüfen
+ if not self.validator_manager.are_generation_conditions_met(
+ code=code,
+ model_name=model_name,
+ is_running=is_running,
+ syntax_check=syntax_check,
+ structure_check=structure_check,
+ ):
+ return
+
+ self.generator_manager.is_running = True
+
+ self.update_output("Die Testskriptgenerierung wurde erfolgreich gestartet...")
+
+ # Callback für die Ergebnisse
+ def handle_result(result):
+ self.update_output(result)
+ self.generator_manager.is_running = False
+
+ # Generierung starten
+ self.generator_manager.start_generate(
+ prompt=prompt_content,
+ code=code,
+ model_name=model_name,
+ callback=handle_result,
+ )
diff --git a/src/ui_settings.py b/src/ui_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..697a9178014cb195cfc9175023359fefa2692be2
--- /dev/null
+++ b/src/ui_settings.py
@@ -0,0 +1,228 @@
+import tkinter as tk
+from tkinter import ttk, scrolledtext
+
+
+class UISettings(tk.Frame):
+ def __init__(self, main_app, switch_frame_callback, prompt_manager, validator_manager):
+ super().__init__(main_app.root, bg="#E0E0E0")
+ self.main_app = main_app
+ self.prompt_manager = prompt_manager
+ self.validator_manager = validator_manager
+
+ self.switch_frame_callback = switch_frame_callback
+ self.initial_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:\n\n### Requirements ###\n"
+ "* 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.\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"
+ "### Here comes the code to be tested ###"
+ )
+
+ self.create_widgets()
+
+ def create_widgets(self):
+ """
+ Erstellt die Widgets für die Einstellungsansicht.
+ """
+ # Hauptinhaltsbereich
+ content_frame = tk.Frame(self, bg="#E0E0E0", padx=15, pady=15)
+ content_frame.pack(fill=tk.BOTH, expand=True)
+
+ # Einstellungen und Prompt-Erstellung in zwei Spalten aufteilen
+ settings_frame = tk.Frame(content_frame, bg="#FFFFFF", bd=1, relief="solid", padx=10, pady=10)
+ settings_frame.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
+
+ prompt_frame = tk.Frame(content_frame, bg="#FFFFFF", bd=1, relief="solid", padx=10, pady=10)
+ prompt_frame.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
+
+ # Rahmen für die Buttons
+ button_frame = tk.Frame(content_frame, bg="#E0E0E0")
+ button_frame.grid(row=1, column=0, columnspan=2, pady=(10, 0))
+
+ # --- Einstellungen-Bereich ---
+ tk.Label(
+ settings_frame,
+ text="Einstellungen",
+ font=("Arial", 16, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 30))
+
+ tk.Label(
+ settings_frame,
+ text="Prompt auswählen:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 5))
+
+ self.prompt_selector = ttk.Combobox(
+ settings_frame,
+ textvariable=self.prompt_manager.selected_prompt,
+ values=list(self.prompt_manager.prompts.keys()),
+ state="readonly",
+ )
+ self.prompt_selector.pack(fill=tk.X, pady=40)
+
+ tk.Label(
+ settings_frame,
+ text="Syntaxprüfung:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 5))
+
+ syntax_check_option = tk.Checkbutton(
+ settings_frame,
+ text="aktivieren",
+ font=("Arial", 12),
+ bg="#FFFFFF",
+ fg="#333333",
+ variable=self.validator_manager.syntax_check_option,
+ )
+ syntax_check_option.pack(anchor="w", pady=40)
+
+ tk.Label(
+ settings_frame,
+ text="Strukturprüfung:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 5))
+
+ structure_check_option = tk.Checkbutton(
+ settings_frame,
+ text="aktivieren",
+ font=("Arial", 12),
+ bg="#FFFFFF",
+ fg="#333333",
+ variable=self.validator_manager.structure_check_option,
+ )
+ structure_check_option.pack(anchor="w", pady=40)
+
+ tk.Label(
+ settings_frame,
+ text="Ausgewählten Prompt löschen:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 5))
+
+ delete_prompt_button = tk.Button(
+ settings_frame,
+ text="Löschen",
+ command=lambda: self.delete(),
+ font=("Arial", 12, "bold"),
+ bg="#FF6B6B",
+ fg="#333333",
+ highlightbackground="#FFFFFF",
+ )
+ delete_prompt_button.pack(fill=tk.X, pady=40)
+
+ # --- Prompt-Erstellungs-Bereich ---
+ tk.Label(
+ prompt_frame,
+ text="Prompt erstellen",
+ font=("Arial", 16, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=(0, 10))
+
+ tk.Label(
+ prompt_frame,
+ text="Titel:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=5)
+
+ self.prompt_titel_text = tk.Entry(
+ prompt_frame,
+ font=("Arial", 12),
+ bg="#F9F9F9",
+ fg="#333333",
+ highlightbackground="#FFFFFF",
+ )
+ self.prompt_titel_text.pack(fill=tk.X, pady=5)
+
+ tk.Label(
+ prompt_frame,
+ text="Prompt-Text:",
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ ).pack(anchor="w", pady=5)
+
+ self.prompt_text = scrolledtext.ScrolledText(
+ prompt_frame,
+ wrap=tk.WORD,
+ font=("Courier New", 12),
+ bg="#F9F9F9",
+ fg="#333333",
+ )
+ self.prompt_text.pack(fill=tk.BOTH, expand=True, pady=5)
+ self.prompt_text.insert("1.0", self.initial_prompt)
+
+ # --- Buttons ---
+ save_prompt_button = tk.Button(
+ button_frame,
+ text="Prompt speichern",
+ command=lambda: self.save_prompt(),
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ highlightcolor="#999999",
+ highlightbackground="#E0E0E0",
+ width=18,
+ height=2,
+ )
+ save_prompt_button.grid(row=0, column=0, padx=5, pady=5)
+
+ back_button = tk.Button(
+ button_frame,
+ text="Zurück",
+ command=lambda: self.switch_frame_callback(self.main_app.main_frame),
+ font=("Arial", 12, "bold"),
+ bg="#FFFFFF",
+ fg="#333333",
+ highlightcolor="#999999",
+ highlightbackground="#E0E0E0",
+ width=18,
+ height=2,
+ )
+ back_button.grid(row=0, column=1, padx=5, pady=5)
+
+ # Layout-Management
+ content_frame.grid_columnconfigure(0, weight=1)
+ content_frame.grid_columnconfigure(1, weight=1)
+ content_frame.grid_rowconfigure(0, weight=1)
+
+ def update_prompt_selection(self):
+ """
+ Aktualisiert die Auswahlmöglichkeiten für die Prompts.
+ """
+ self.prompt_selector["values"] = list(self.prompt_manager.prompts.keys())
+
+ def save_prompt(self):
+ """
+ Speichert den erstellten Prompt.
+ """
+ title = self.prompt_titel_text.get()
+ content = self.prompt_text.get("1.0", tk.END).strip()
+ # Update Promptvorlage, für erfolgreihe Erstellung
+ is_successful = self.prompt_manager.successful_save_prompt_to_json(title, content)
+ if is_successful:
+ self.prompt_titel_text.delete(0, tk.END)
+ self.prompt_text.insert("1.0", self.initial_prompt)
+ self.update_prompt_selection()
+
+ def delete(self):
+ """
+ Löscht den aktuell ausgewählten Prompt.
+ """
+ self.prompt_manager.delete_prompt(self.prompt_selector.get())
+ self.update_prompt_selection()
diff --git a/src/validator_manager.py b/src/validator_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..831a4983fe538de47db7c3c88e8c0a57cbe5c45c
--- /dev/null
+++ b/src/validator_manager.py
@@ -0,0 +1,78 @@
+import tkinter as tk
+import ast
+import subprocess
+from tkinter import messagebox
+
+class Validator_Manager:
+ def __init__(self):
+ self.syntax_check_option = tk.BooleanVar(value=True)
+ self.structure_check_option = tk.BooleanVar(value=True)
+
+ def are_generation_conditions_met(self, code, model_name, is_running=True, syntax_check=True, structure_check=True):
+ """
+ Prüft ob die Bedingungen für die Generierung eines Testskripts erfüllt sind.
+ """
+ if is_running:
+ messagebox.showinfo("Generierung läuft", "Testskriptgenerierung läuft bereits, bitte warten Sie.")
+ return False
+
+ if not self.is_model_available(model_name):
+ return False
+
+ if not code.strip():
+ messagebox.showerror("Fehler", "Die Musterlösung darf nicht leer sein. Bitte geben Sie eine Musterlösung ein.")
+ return False
+
+ if syntax_check and not self.is_syntax_valid(code):
+ messagebox.showerror("Fehler", "Der eingegebene Code enthält Syntaxfehler, bitte korrigieren Sie diese oder deaktivieren Sie die Syntaxprüfung.")
+ return False
+
+ if structure_check and not self.has_testable_structures(code):
+ messagebox.showerror("Fehler", "Der eingegebene Code enthält keine klassisch testbaren Strukturen (Funktionen oder Klassen), wenn Sie die Generierung dennoch starten möchten, deaktivieren Sie die Strukturprüfung.")
+ return False
+
+ else:
+ return True
+
+ def is_syntax_valid(self, code):
+ """
+ Überprüft, ob der Code syntaktisch korrekt ist.
+ """
+ try:
+ compile(code, "<string>", "exec")
+ return True
+ except SyntaxError:
+ return False
+
+ def has_testable_structures(self, code):
+ """
+ Überprüft, ob der Code Funktionen oder Klassen enthält.
+ """
+ try:
+ tree = ast.parse(code)
+ for node in ast.walk(tree):
+ if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+ return True
+ return False
+ except SyntaxError:
+ return False
+
+ def is_model_available(self, model_name):
+ """
+ Prüft, ob das angegebene Modell mit Ollama installiert und verfügbar ist.
+ """
+ try:
+ result = subprocess.run(
+ ["ollama", "list"],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True
+ )
+ if model_name in result.stdout:
+ return True
+ else:
+ messagebox.showerror("Fehler", "Ollama oder das Modell ("+ model_name +") ist nicht installiert oder nicht im PATH verfügbar. Bitte versichern Sie sich, dass sowohl Ollama als auch das Modell installiert sind.")
+ return False
+ except FileNotFoundError:
+ messagebox.showerror("Fehler", "Ollama oder das Modell ("+ model_name +") ist nicht installiert oder nicht im PATH verfügbar. Bitte versichern Sie sich, dass sowohl Ollama als auch das Modell installiert sind.")
+ return False