Added a basic test for the worker get methods

.gitignore

@@ -1,2 +1 @@
-build/
 .gradle/

.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Wed Dec 03 17:27:55 CET 2025
+gradle.version=8.14

.idea/gradle.xml

@@ -5,8 +5,6 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleHome" value="C:\Gradle\gradle-9.0.0" />
-        <option name="gradleJvm" value="17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="homebrew-17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/modules/Template.iml" filepath="$PROJECT_DIR$/.idea/modules/Template.iml" />
-      <module fileurl="file://$PROJECT_DIR$/.idea/modules/Template.test.iml" filepath="$PROJECT_DIR$/.idea/modules/Template.test.iml" />
-    </modules>
-  </component>
-</project>

.idea/modules/Template.test.iml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module version="4">
-  <component name="AdditionalModuleElements">
-    <content url="file://$MODULE_DIR$/../../src/test" dumb="true">
-      <sourceFolder url="file://$MODULE_DIR$/../../src/test/resources" type="java-test-resource" />
-    </content>
-  </component>
-</module>

README.md

@@ -1,40 +1,2 @@
-@Author Kevin Schoenmayer, Riley Schneider, Can Oezdemir, Lasse Grosshans
+# Temp-Java-Gradle
-
-Volle Dokumentation mit Bildern, Vorbereitungen und Klassendiagramm unter
-https://docs.google.com/document/d/1iPl3XoZdvn1zqYCNlzHklEf_bRBGnQm41bAEaWz_s0w/edit?usp=sharing
-
-
-Voraussetzungen:
-Docker (inkl. Docker Compose)
-Java 17
-Git
-
-Projekt bauen, testen und starten:
-
-1. Projekt klonen:
-git clone https://home.luithardt.cloud:5400/KevinSchoenmayer/GseTDDUebungKCLR
-
-2. Zu ...\GseTDDUebungKCLR\docker in cmd navigieren
-Docker starten:
-docker compose up -d
-
-3. Tabellenerstellung fuer die Testumgebung:
-Verbinden Sie sich mit dem Programm Ihrer Wahl mit der Datenbank (z.B. HeidiSQL). Die Anmeldeinformationen finden Sie in der compose.yml-Datei.
-Fuehren Sie nun auf der Datenbank folgende SQL-Befehle aus dieser Dateien aus:
-resources\sql\createTaskTable.sql
-resources\sql\createWorkerTable.sql
-Sie sollten in Ihrer Datenbank nun zwei neue Tabellen sehen: Task und Worker. Wenn dem so sei, koennen Sie mit Punkt (6) fortfahren.
-
-4. Projekt starten:
-gradle cleanRun --console=plain --quiet
-Jetzt werden die Tests durchgefuehrt und in
-...\GseTDDUebungKCLR\build\reports\tests\index.html
-gespeichert (genaue Adresse fuer .html wird automatisch angegeben),
-die Jacoco Test Coverage erzeugt und in 
-...\GseTDDUebungKCLR\build\reports\jacoco\html\index.html
-gespeichert (genaue Adresse fuer .html wird automatisch angegeben),
-und das Programm in der Command Line gestartet.
-
-Nutze ?, um dir die Befehle anzeigen zu lassen.
-
 

build.gradle

@@ -1,7 +1,6 @@
 plugins {
     id 'java'
     id 'jacoco'
-    id 'application'
 }
 
 group = 'hhn.temp.project'
@@ -15,7 +14,11 @@ dependencies {
     testImplementation platform('org.junit:junit-bom:5.10.0')
     testImplementation 'org.junit.jupiter:junit-jupiter'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
-    implementation 'com.mysql:mysql-connector-j:9.5.0'
+}
+
+jacoco {
+    toolVersion = '0.8.13'
+    reportsDirectory.set(layout.buildDirectory.dir('customJacocoReportDir'))
 }
 
 sourceSets {
@@ -31,7 +34,6 @@ sourceSets {
     }
 }
 
-// Test configuration
 test {
     useJUnitPlatform()
     testLogging {
@@ -39,105 +41,13 @@ test {
         exceptionFormat "full"
         showStandardStreams = true
     }
-
-    // Generate test reports in a specific location
-    reports {
-        html.outputLocation.set(layout.buildDirectory.dir("reports/tests"))
-        junitXml.outputLocation.set(layout.buildDirectory.dir("reports/tests"))
-    }
-
     finalizedBy jacocoTestReport
 }
-
-// Jacoco configuration
-jacoco {
-    toolVersion = '0.8.13'
-    reportsDirectory.set(layout.buildDirectory.dir('reports/jacoco'))
-}
-
 jacocoTestReport {
     dependsOn test
     reports {
-        xml.required = true
+        xml.required = false
         csv.required = false
-        html.required = true
+        html.outputLocation.set(layout.buildDirectory.dir('jacocoHtml'))
-        html.outputLocation.set(layout.buildDirectory.dir("reports/jacoco/html"))
     }
-}
+}
-
-// Application configuration
-application {
-    mainClass = "hhn.temp.project.Main"
-}
-
-// Custom task to print information after build
-task printInfo {
-    dependsOn test, jacocoTestReport
-    doLast {
-        println("\n" + "="*50)
-        println("BUILD AND TESTS COMPLETED SUCCESSFULLY!")
-        println("="*50)
-        println("\nTest Results Location:")
-        println("  HTML: ${layout.buildDirectory.get()}/reports/tests/index.html")
-        println("  XML:  ${layout.buildDirectory.get()}/reports/tests/TEST-*.xml")
-
-        println("\nJacoco Coverage Reports:")
-        println("  HTML: ${layout.buildDirectory.get()}/reports/jacoco/html/index.html")
-        println("  XML:  ${layout.buildDirectory.get()}/reports/jacoco/test/jacocoTestReport.xml")
-
-        println("\nTo run the application:")
-        println("  gradle run --console=plain")
-        println("\nTo run tests and generate coverage reports:")
-        println("  gradle test jacocoTestReport")
-        println("="*50)
-    }
-}
-
-// Custom task that combines clean, test, jacocoTestReport
-task cleanTestReport {
-    dependsOn clean, test, jacocoTestReport
-    description = 'Clean build and run tests with coverage reports'
-    group = 'verification'
-}
-
-// Configure the standard run task
-run {
-    dependsOn test, jacocoTestReport
-    standardInput = System.in
-
-    doFirst {
-        println("\n" + "="*50)
-        println("TESTS COMPLETED - STARTING APPLICATION...")
-        println("="*50)
-    }
-}
-
-// Create an alias task
-task cleanRun {
-    dependsOn clean, run
-    description = 'Clean build, run tests with coverage, then run the application'
-    group = 'application'
-}
-
-// Alternative: Create a separate task that doesn't chain dependencies
-task startApp(type: JavaExec) {
-    description = 'Start the application (without running tests first)'
-    group = 'application'
-
-    classpath = sourceSets.main.runtimeClasspath
-    mainClass = application.mainClass
-    standardInput = System.in
-    standardOutput = System.out
-
-    // Configure to run in foreground
-    systemProperties System.getProperties()
-
-    doFirst {
-        println("\n" + "="*50)
-        println("STARTING APPLICATION...")
-        println("="*50)
-    }
-}
-
-// Make test and jacocoTestReport trigger the info print
-test.finalizedBy printInfo

build/reports/tests/test/classes/Gradle#20Test#20Executor#201.html

@@ -0,0 +1,192 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta http-equiv="x-ua-compatible" content="IE=edge"/>
+<title>Test results - Class Gradle Test Executor 1</title>
+<link href="../css/base-style.css" rel="stylesheet" type="text/css"/>
+<link href="../css/style.css" rel="stylesheet" type="text/css"/>
+<script src="../js/report.js" type="text/javascript"></script>
+</head>
+<body>
+<div id="content">
+<h1>Class Gradle Test Executor 1</h1>
+<div class="breadcrumbs">
+<a href="../index.html">all</a> &gt; 
+<a href="../packages/default-package.html">default-package</a> &gt; Gradle Test Executor 1</div>
+<div id="summary">
+<table>
+<tr>
+<td>
+<div class="summaryGroup">
+<table>
+<tr>
+<td>
+<div class="infoBox" id="tests">
+<div class="counter">1</div>
+<p>tests</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="failures">
+<div class="counter">1</div>
+<p>failures</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="ignored">
+<div class="counter">0</div>
+<p>ignored</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="duration">
+<div class="counter">0.293s</div>
+<p>duration</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</td>
+<td>
+<div class="infoBox failures" id="successRate">
+<div class="percent">0%</div>
+<p>successful</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="tab-container">
+<ul class="tabLinks">
+<li>
+<a href="#">Failed tests</a>
+</li>
+<li>
+<a href="#">Tests</a>
+</li>
+</ul>
+<div class="tab">
+<h2>Failed tests</h2>
+<div class="test">
+<a name="failed to execute tests"></a>
+<h3 class="failures">failed to execute tests</h3>
+<span class="code">
+<pre id="test-message-failed to execute tests">org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.BadCasesTest'.
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:56)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
+	at java.base@17.0.12/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.base@17.0.12/java.lang.reflect.Method.invoke(Method.java:568)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:36)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
+	at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:33)
+	at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:92)
+	at jdk.proxy2/jdk.proxy2.$Proxy6.processTestClass(Unknown Source)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker$2.run(TestWorker.java:177)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.executeAndMaintainThreadName(TestWorker.java:126)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:103)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:63)
+	at org.gradle.process.internal.worker.child.ActionExecutionWorker.execute(ActionExecutionWorker.java:56)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:122)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:72)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.run(GradleWorkerMain.java:69)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.main(GradleWorkerMain.java:74)
+Caused by: java.lang.SecurityException: Prohibited package name: java
+	at java.base/java.lang.ClassLoader.preDefineClass(ClassLoader.java:900)
+	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1015)
+	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:150)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:862)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:760)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:681)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:639)
+	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
+	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:525)
+	at java.base/java.lang.Class.forName0(Native Method)
+	at java.base/java.lang.Class.forName(Class.java:467)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.loadClass(JUnitPlatformTestClassProcessor.java:184)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.access$100(JUnitPlatformTestClassProcessor.java:62)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:120)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:110)
+	at org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:61)
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:54)
+	... 18 more
+</pre>
+<button class="clipboard-copy-btn" aria-label="Copy to clipboard" data-copy-element-id="test-message-failed to execute tests">Copy</button>
+</span>
+<span class="code">
+<pre id="test-message-failed to execute tests">org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.GoodCasesTest'.
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:56)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
+	at java.base@17.0.12/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.base@17.0.12/java.lang.reflect.Method.invoke(Method.java:568)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:36)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
+	at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:33)
+	at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:92)
+	at jdk.proxy2/jdk.proxy2.$Proxy6.processTestClass(Unknown Source)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker$2.run(TestWorker.java:177)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.executeAndMaintainThreadName(TestWorker.java:126)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:103)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:63)
+	at org.gradle.process.internal.worker.child.ActionExecutionWorker.execute(ActionExecutionWorker.java:56)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:122)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:72)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.run(GradleWorkerMain.java:69)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.main(GradleWorkerMain.java:74)
+Caused by: java.lang.SecurityException: Prohibited package name: java
+	at java.base/java.lang.ClassLoader.preDefineClass(ClassLoader.java:900)
+	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1015)
+	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:150)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:862)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:760)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:681)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:639)
+	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
+	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:525)
+	at java.base/java.lang.Class.forName0(Native Method)
+	at java.base/java.lang.Class.forName(Class.java:467)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.loadClass(JUnitPlatformTestClassProcessor.java:184)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.access$100(JUnitPlatformTestClassProcessor.java:62)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:120)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:110)
+	at org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:61)
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:54)
+	... 18 more
+</pre>
+<button class="clipboard-copy-btn" aria-label="Copy to clipboard" data-copy-element-id="test-message-failed to execute tests">Copy</button>
+</span>
+</div>
+</div>
+<div class="tab">
+<h2>Tests</h2>
+<table>
+<thead>
+<tr>
+<th>Test</th>
+<th>Duration</th>
+<th>Result</th>
+</tr>
+</thead>
+<tr>
+<td class="failures">failed to execute tests</td>
+<td class="failures">0.293s</td>
+<td class="failures">failed</td>
+</tr>
+</table>
+</div>
+</div>
+<div id="footer">
+<p>
+<div>
+<label class="hidden" id="label-for-line-wrapping-toggle" for="line-wrapping-toggle">Wrap lines
+<input id="line-wrapping-toggle" type="checkbox" autocomplete="off"/>
+</label>
+</div>Generated by 
+<a href="https://www.gradle.org">Gradle 9.1.0</a> at 03.12.2025, 16:01:59</p>
+</div>
+</div>
+</body>
+</html>

build/reports/tests/test/css/base-style.css

@@ -0,0 +1,174 @@
+
+body {
+    margin: 0;
+    padding: 0;
+    font-family: sans-serif;
+    font-size: 12pt;
+}
+
+body, a, a:visited {
+    color: #303030;
+}
+
+#content {
+    padding: 30px 50px;
+}
+
+#content h1 {
+    font-size: 160%;
+    margin-bottom: 10px;
+}
+
+#footer {
+    margin-top: 100px;
+    font-size: 80%;
+    white-space: nowrap;
+}
+
+#footer, #footer a {
+    color: #a0a0a0;
+}
+
+#line-wrapping-toggle {
+    vertical-align: middle;
+}
+
+#label-for-line-wrapping-toggle {
+    vertical-align: middle;
+}
+
+ul {
+    margin-left: 0;
+}
+
+h1, h2, h3 {
+    white-space: nowrap;
+}
+
+h2 {
+    font-size: 120%;
+}
+
+.tab-container .tab-container {
+    margin-left: 8px;
+}
+
+ul.tabLinks {
+    padding: 0;
+    margin-bottom: 0;
+    overflow: auto;
+    min-width: 800px;
+    width: auto;
+    border-bottom: solid 1px #aaa;
+}
+
+ul.tabLinks li {
+    float: left;
+    height: 100%;
+    list-style: none;
+    padding: 5px 10px;
+    border-radius: 7px 7px 0 0;
+    border: solid 1px transparent;
+    border-bottom: none;
+    margin-right: 6px;
+    background-color: #f0f0f0;
+}
+
+ul.tabLinks li.deselected > a {
+    color: #6d6d6d;
+}
+
+ul.tabLinks li:hover {
+    background-color: #fafafa;
+}
+
+ul.tabLinks li.selected {
+    background-color: #c5f0f5;
+    border-color: #aaa;
+}
+
+ul.tabLinks a {
+    font-size: 120%;
+    display: block;
+    outline: none;
+    text-decoration: none;
+    margin: 0;
+    padding: 0;
+}
+
+ul.tabLinks li h2 {
+    margin: 0;
+    padding: 0;
+}
+
+div.tab {
+}
+
+div.selected {
+    display: block;
+}
+
+div.deselected {
+    display: none;
+}
+
+div.tab table {
+    min-width: 350px;
+    width: auto;
+    border-collapse: collapse;
+}
+
+div.tab th, div.tab table {
+    border-bottom: solid 1px #d0d0d0;
+}
+
+div.tab th {
+    text-align: left;
+    white-space: nowrap;
+    padding-left: 6em;
+}
+
+div.tab th:first-child {
+    padding-left: 0;
+}
+
+div.tab td {
+    white-space: nowrap;
+    padding-left: 6em;
+    padding-top: 5px;
+    padding-bottom: 5px;
+}
+
+div.tab td:first-child {
+    padding-left: 0;
+}
+
+div.tab td.numeric, div.tab th.numeric {
+    text-align: right;
+}
+
+span.code {
+    display: inline-block;
+    margin-top: 0;
+    margin-bottom: 1em;
+}
+
+span.code pre {
+    font-size: 11pt;
+    padding: 10px;
+    margin: 0;
+    background-color: #f7f7f7;
+    border: solid 1px #d0d0d0;
+    min-width: 700px;
+    width: auto;
+}
+
+span.wrapped pre {
+    word-wrap: break-word;
+    white-space: pre-wrap;
+    word-break: break-all;
+}
+
+label.hidden {
+    display: none;
+}

build/reports/tests/test/css/style.css

@@ -0,0 +1,97 @@
+
+#summary {
+    margin-top: 30px;
+    margin-bottom: 40px;
+}
+
+#summary table {
+    border-collapse: collapse;
+}
+
+#summary td {
+    vertical-align: top;
+}
+
+.breadcrumbs, .breadcrumbs a {
+    color: #606060;
+}
+
+.infoBox {
+    width: 110px;
+    padding-top: 15px;
+    padding-bottom: 15px;
+    text-align: center;
+}
+
+.infoBox p {
+    margin: 0;
+}
+
+.counter, .percent {
+    font-size: 120%;
+    font-weight: bold;
+    margin-bottom: 8px;
+}
+
+#duration {
+    width: 125px;
+}
+
+#successRate, .summaryGroup {
+    border: solid 2px #d0d0d0;
+    -moz-border-radius: 10px;
+    border-radius: 10px;
+}
+
+#successRate {
+    width: 140px;
+    margin-left: 35px;
+}
+
+#successRate .percent {
+    font-size: 180%;
+}
+
+.success, .success a {
+    color: #008000;
+}
+
+div.success, #successRate.success {
+    background-color: #bbd9bb;
+    border-color: #008000;
+}
+
+.failures, .failures a {
+    color: #b60808;
+}
+
+.skipped, .skipped a {
+    color: #c09853;
+}
+
+div.failures, #successRate.failures {
+    background-color: #ecdada;
+    border-color: #b60808;
+}
+
+ul.linkList {
+    padding-left: 0;
+}
+
+ul.linkList li {
+    list-style: none;
+    margin-bottom: 5px;
+}
+
+.code {
+    position: relative;
+}
+
+.clipboard-copy-btn {
+    position: absolute;
+    top: 8px;
+    right: 8px;
+    padding: 4px 8px;
+    font-size: 0.9em;
+    cursor: pointer;
+}

build/reports/tests/test/index.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta http-equiv="x-ua-compatible" content="IE=edge"/>
+<title>Test results - Test Summary</title>
+<link href="css/base-style.css" rel="stylesheet" type="text/css"/>
+<link href="css/style.css" rel="stylesheet" type="text/css"/>
+<script src="js/report.js" type="text/javascript"></script>
+</head>
+<body>
+<div id="content">
+<h1>Test Summary</h1>
+<div id="summary">
+<table>
+<tr>
+<td>
+<div class="summaryGroup">
+<table>
+<tr>
+<td>
+<div class="infoBox" id="tests">
+<div class="counter">1</div>
+<p>tests</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="failures">
+<div class="counter">1</div>
+<p>failures</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="ignored">
+<div class="counter">0</div>
+<p>ignored</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="duration">
+<div class="counter">0.293s</div>
+<p>duration</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</td>
+<td>
+<div class="infoBox failures" id="successRate">
+<div class="percent">0%</div>
+<p>successful</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="tab-container">
+<ul class="tabLinks">
+<li>
+<a href="#">Failed tests</a>
+</li>
+<li>
+<a href="#">Packages</a>
+</li>
+<li>
+<a href="#">Classes</a>
+</li>
+</ul>
+<div class="tab">
+<h2>Failed tests</h2>
+<ul class="linkList">
+<li>
+<a href="classes/Gradle%2320Test%2320Executor%23201.html">Gradle Test Executor 1</a>.
+<a href="classes/Gradle%2320Test%2320Executor%23201.html#failed to execute tests">failed to execute tests</a>
+</li>
+</ul>
+</div>
+<div class="tab">
+<h2>Packages</h2>
+<table>
+<thead>
+<tr>
+<th>Package</th>
+<th>Tests</th>
+<th>Failures</th>
+<th>Ignored</th>
+<th>Duration</th>
+<th>Success rate</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="failures">
+<a href="packages/default-package.html">default-package</a>
+</td>
+<td>1</td>
+<td>1</td>
+<td>0</td>
+<td>0.293s</td>
+<td class="failures">0%</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="tab">
+<h2>Classes</h2>
+<table>
+<thead>
+<tr>
+<th>Class</th>
+<th>Tests</th>
+<th>Failures</th>
+<th>Ignored</th>
+<th>Duration</th>
+<th>Success rate</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="failures">
+<a href="classes/Gradle%2320Test%2320Executor%23201.html">Gradle Test Executor 1</a>
+</td>
+<td>1</td>
+<td>1</td>
+<td>0</td>
+<td>0.293s</td>
+<td class="failures">0%</td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div id="footer">
+<p>
+<div>
+<label class="hidden" id="label-for-line-wrapping-toggle" for="line-wrapping-toggle">Wrap lines
+<input id="line-wrapping-toggle" type="checkbox" autocomplete="off"/>
+</label>
+</div>Generated by 
+<a href="https://www.gradle.org">Gradle 9.1.0</a> at 03.12.2025, 16:01:59</p>
+</div>
+</div>
+</body>
+</html>

build/reports/tests/test/js/report.js

@@ -0,0 +1,243 @@
+(function (window, document) {
+    "use strict";
+
+    function changeElementClass(element, classValue) {
+        if (element.getAttribute("className")) {
+            element.setAttribute("className", classValue);
+        } else {
+            element.setAttribute("class", classValue);
+        }
+    }
+
+    function getClassAttribute(element) {
+        if (element.getAttribute("className")) {
+            return element.getAttribute("className");
+        } else {
+            return element.getAttribute("class");
+        }
+    }
+
+    function addClass(element, classValue) {
+        changeElementClass(element, getClassAttribute(element) + " " + classValue);
+    }
+
+    function removeClass(element, classValue) {
+        changeElementClass(element, getClassAttribute(element).replace(classValue, ""));
+    }
+
+    function getCheckBox() {
+        return document.getElementById("line-wrapping-toggle");
+    }
+
+    function getLabelForCheckBox() {
+        return document.getElementById("label-for-line-wrapping-toggle");
+    }
+
+    function findCodeBlocks() {
+        const codeBlocks = [];
+        const tabContainers = getTabContainers();
+        for (let i = 0; i < tabContainers.length; i++) {
+            const spans = tabContainers[i].getElementsByTagName("span");
+            for (let i = 0; i < spans.length; ++i) {
+                if (spans[i].className.indexOf("code") >= 0) {
+                    codeBlocks.push(spans[i]);
+                }
+            }
+        }
+        return codeBlocks;
+    }
+
+    function forAllCodeBlocks(operation) {
+        const codeBlocks = findCodeBlocks();
+
+        for (let i = 0; i < codeBlocks.length; ++i) {
+            operation(codeBlocks[i], "wrapped");
+        }
+    }
+
+    function toggleLineWrapping() {
+        const checkBox = getCheckBox();
+
+        if (checkBox.checked) {
+            forAllCodeBlocks(addClass);
+        } else {
+            forAllCodeBlocks(removeClass);
+        }
+    }
+
+    function initClipboardCopyButton() {
+        document.querySelectorAll(".clipboard-copy-btn").forEach((button) => {
+            const copyElementId = button.getAttribute("data-copy-element-id");
+            const elementWithCodeToSelect = document.getElementById(copyElementId);
+
+            button.addEventListener("click", () => {
+                const text = elementWithCodeToSelect.innerText.trim();
+                navigator.clipboard
+                    .writeText(text)
+                    .then(() => {
+                        button.textContent = "Copied!";
+                        setTimeout(() => {
+                            button.textContent = "Copy";
+                        }, 1500);
+                    })
+                    .catch((err) => {
+                        alert("Failed to copy to the clipboard: '" + err.message + "'. Check JavaScript console for more details.")
+                        console.warn("Failed to copy to the clipboard", err);
+                    });
+            });
+        });
+    }
+
+    function initControls() {
+        if (findCodeBlocks().length > 0) {
+            const checkBox = getCheckBox();
+            const label = getLabelForCheckBox();
+
+            checkBox.onclick = toggleLineWrapping;
+            checkBox.checked = false;
+
+            removeClass(label, "hidden");
+         }
+
+         initClipboardCopyButton()
+    }
+
+    class TabManager {
+        baseId;
+        tabs;
+        titles;
+        headers;
+
+        constructor(baseId, tabs, titles, headers) {
+            this.baseId = baseId;
+            this.tabs = tabs;
+            this.titles = titles;
+            this.headers = headers;
+        }
+
+        select(i) {
+            this.deselectAll();
+
+            changeElementClass(this.tabs[i], "tab selected");
+            changeElementClass(this.headers[i], "selected");
+
+            while (this.headers[i].firstChild) {
+                this.headers[i].removeChild(this.headers[i].firstChild);
+            }
+
+            const a = document.createElement("a");
+
+            a.appendChild(document.createTextNode(this.titles[i]));
+            this.headers[i].appendChild(a);
+        }
+
+        deselectAll() {
+            for (let i = 0; i < this.tabs.length; i++) {
+                changeElementClass(this.tabs[i], "tab deselected");
+                changeElementClass(this.headers[i], "deselected");
+
+                while (this.headers[i].firstChild) {
+                    this.headers[i].removeChild(this.headers[i].firstChild);
+                }
+
+                const a = document.createElement("a");
+
+                const id = this.baseId + "-tab" + i;
+                a.setAttribute("id", id);
+                a.setAttribute("href", "#tab" + i);
+                a.onclick = () => {
+                    this.select(i);
+                    return false;
+                };
+                a.appendChild(document.createTextNode(this.titles[i]));
+
+                this.headers[i].appendChild(a);
+            }
+        }
+    }
+
+    function getTabContainers() {
+        const tabContainers = Array.from(document.getElementsByClassName("tab-container"));
+
+        // Used by existing TabbedPageRenderer users, which have not adjusted to use TabsRenderer yet.
+        const legacyContainer = document.getElementById("tabs");
+        if (legacyContainer) {
+            tabContainers.push(legacyContainer);
+        }
+
+        return tabContainers;
+    }
+
+    function initTabs() {
+        let tabGroups = 0;
+
+        function createTab(num, container) {
+            const tabElems = findTabs(container);
+            const tabManager = new TabManager("tabs" + num, tabElems, findTitles(tabElems), findHeaders(container));
+            tabManager.select(0);
+        }
+
+        const tabContainers = getTabContainers();
+
+        for (let i = 0; i < tabContainers.length; i++) {
+            createTab(tabGroups, tabContainers[i]);
+            tabGroups++;
+        }
+
+        return true;
+    }
+
+    function findTabs(container) {
+        return findChildElements(container, "DIV", "tab");
+    }
+
+    function findHeaders(container) {
+        const owner = findChildElements(container, "UL", "tabLinks");
+        return findChildElements(owner[0], "LI", null);
+    }
+
+    function findTitles(tabs) {
+        const titles = [];
+
+        for (let i = 0; i < tabs.length; i++) {
+            const tab = tabs[i];
+            const header = findChildElements(tab, "H2", null)[0];
+
+            header.parentNode.removeChild(header);
+
+            if (header.innerText) {
+                titles.push(header.innerText);
+            } else {
+                titles.push(header.textContent);
+            }
+        }
+
+        return titles;
+    }
+
+    function findChildElements(container, name, targetClass) {
+        const elements = [];
+        const children = container.childNodes;
+
+        for (let i = 0; i < children.length; i++) {
+            const child = children.item(i);
+
+            if (child.nodeType === 1 && child.nodeName === name) {
+                if (targetClass && child.className.indexOf(targetClass) < 0) {
+                    continue;
+                }
+
+                elements.push(child);
+            }
+        }
+
+        return elements;
+    }
+
+    // Entry point.
+
+    window.onload = function() {
+        initTabs();
+        initControls();
+    };
+} (window, window.document));

build/reports/tests/test/packages/default-package.html

@@ -0,0 +1,115 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta http-equiv="x-ua-compatible" content="IE=edge"/>
+<title>Test results - Default package</title>
+<link href="../css/base-style.css" rel="stylesheet" type="text/css"/>
+<link href="../css/style.css" rel="stylesheet" type="text/css"/>
+<script src="../js/report.js" type="text/javascript"></script>
+</head>
+<body>
+<div id="content">
+<h1>Default package</h1>
+<div class="breadcrumbs">
+<a href="../index.html">all</a> &gt; default-package</div>
+<div id="summary">
+<table>
+<tr>
+<td>
+<div class="summaryGroup">
+<table>
+<tr>
+<td>
+<div class="infoBox" id="tests">
+<div class="counter">1</div>
+<p>tests</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="failures">
+<div class="counter">1</div>
+<p>failures</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="ignored">
+<div class="counter">0</div>
+<p>ignored</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="duration">
+<div class="counter">0.293s</div>
+<p>duration</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</td>
+<td>
+<div class="infoBox failures" id="successRate">
+<div class="percent">0%</div>
+<p>successful</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="tab-container">
+<ul class="tabLinks">
+<li>
+<a href="#">Failed tests</a>
+</li>
+<li>
+<a href="#">Classes</a>
+</li>
+</ul>
+<div class="tab">
+<h2>Failed tests</h2>
+<ul class="linkList">
+<li>
+<a href="../classes/Gradle%2320Test%2320Executor%23201.html">Gradle Test Executor 1</a>.
+<a href="../classes/Gradle%2320Test%2320Executor%23201.html#failed to execute tests">failed to execute tests</a>
+</li>
+</ul>
+</div>
+<div class="tab">
+<h2>Classes</h2>
+<table>
+<thead>
+<tr>
+<th>Class</th>
+<th>Tests</th>
+<th>Failures</th>
+<th>Ignored</th>
+<th>Duration</th>
+<th>Success rate</th>
+</tr>
+</thead>
+<tr>
+<td class="failures">
+<a href="../classes/Gradle%2320Test%2320Executor%23201.html">Gradle Test Executor 1</a>
+</td>
+<td>1</td>
+<td>1</td>
+<td>0</td>
+<td>0.293s</td>
+<td class="failures">0%</td>
+</tr>
+</table>
+</div>
+</div>
+<div id="footer">
+<p>
+<div>
+<label class="hidden" id="label-for-line-wrapping-toggle" for="line-wrapping-toggle">Wrap lines
+<input id="line-wrapping-toggle" type="checkbox" autocomplete="off"/>
+</label>
+</div>Generated by 
+<a href="https://www.gradle.org">Gradle 9.1.0</a> at 03.12.2025, 16:01:59</p>
+</div>
+</div>
+</body>
+</html>

build/test-results/test/TEST-Gradle#20Test#20Executor#201.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="Gradle Test Executor 1" tests="1" skipped="0" failures="1" errors="0" timestamp="2025-12-03T15:01:58.682Z" hostname="FERRYRY" time="0.293">
+  <properties/>
+  <testcase name="failed to execute tests" classname="Gradle Test Executor 1" time="0.293">
+    <failure message="org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.BadCasesTest'." type="org.gradle.api.internal.tasks.testing.TestSuiteExecutionException">org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.BadCasesTest'.
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:56)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
+	at java.base@17.0.12/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.base@17.0.12/java.lang.reflect.Method.invoke(Method.java:568)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:36)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
+	at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:33)
+	at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:92)
+	at jdk.proxy2/jdk.proxy2.$Proxy6.processTestClass(Unknown Source)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker$2.run(TestWorker.java:177)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.executeAndMaintainThreadName(TestWorker.java:126)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:103)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:63)
+	at org.gradle.process.internal.worker.child.ActionExecutionWorker.execute(ActionExecutionWorker.java:56)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:122)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:72)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.run(GradleWorkerMain.java:69)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.main(GradleWorkerMain.java:74)
+Caused by: java.lang.SecurityException: Prohibited package name: java
+	at java.base/java.lang.ClassLoader.preDefineClass(ClassLoader.java:900)
+	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1015)
+	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:150)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:862)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:760)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:681)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:639)
+	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
+	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:525)
+	at java.base/java.lang.Class.forName0(Native Method)
+	at java.base/java.lang.Class.forName(Class.java:467)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.loadClass(JUnitPlatformTestClassProcessor.java:184)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.access$100(JUnitPlatformTestClassProcessor.java:62)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:120)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:110)
+	at org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:61)
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:54)
+	... 18 more
+</failure>
+    <failure message="org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.GoodCasesTest'." type="org.gradle.api.internal.tasks.testing.TestSuiteExecutionException">org.gradle.api.internal.tasks.testing.TestSuiteExecutionException: Could not execute test class 'java.GoodCasesTest'.
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:56)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at java.base@17.0.12/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
+	at java.base@17.0.12/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
+	at java.base@17.0.12/java.lang.reflect.Method.invoke(Method.java:568)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:36)
+	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
+	at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:33)
+	at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:92)
+	at jdk.proxy2/jdk.proxy2.$Proxy6.processTestClass(Unknown Source)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker$2.run(TestWorker.java:177)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.executeAndMaintainThreadName(TestWorker.java:126)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:103)
+	at org.gradle.api.internal.tasks.testing.worker.TestWorker.execute(TestWorker.java:63)
+	at org.gradle.process.internal.worker.child.ActionExecutionWorker.execute(ActionExecutionWorker.java:56)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:122)
+	at org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker.call(SystemApplicationClassLoaderWorker.java:72)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.run(GradleWorkerMain.java:69)
+	at app//worker.org.gradle.process.internal.worker.GradleWorkerMain.main(GradleWorkerMain.java:74)
+Caused by: java.lang.SecurityException: Prohibited package name: java
+	at java.base/java.lang.ClassLoader.preDefineClass(ClassLoader.java:900)
+	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1015)
+	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:150)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:862)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:760)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:681)
+	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:639)
+	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
+	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:525)
+	at java.base/java.lang.Class.forName0(Native Method)
+	at java.base/java.lang.Class.forName(Class.java:467)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.loadClass(JUnitPlatformTestClassProcessor.java:184)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor.access$100(JUnitPlatformTestClassProcessor.java:62)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:120)
+	at org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor$CollectAllTestClassesExecutor.execute(JUnitPlatformTestClassProcessor.java:110)
+	at org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:61)
+	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:54)
+	... 18 more
+</failure>
+  </testcase>
+  <system-out><![CDATA[]]></system-out>
+  <system-err><![CDATA[]]></system-err>
+</testsuite>

build/tmp/.cache/expanded/zip_9892ccb804f78c0637616b68610d363f/META-INF/MANIFEST.MF

@@ -0,0 +1,20 @@
+Manifest-Version: 1.0
+Created-By: Apache Maven Bundle Plugin 6.0.0
+Build-Jdk-Spec: 21
+Build-Tool-Jdk-Spec: 21
+Automatic-Module-Name: org.jacoco.agent
+Bnd-LastModified: 1743583180503
+Bundle-Description: JaCoCo Agent
+Bundle-License: https://www.eclipse.org/legal/epl-2.0/
+Bundle-ManifestVersion: 2
+Bundle-Name: JaCoCo Agent
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Bundle-SymbolicName: org.jacoco.agent
+Bundle-Vendor: Mountainminds GmbH & Co. KG
+Bundle-Version: 0.8.13.202504020838
+Eclipse-SourceReferences: scm:git:git://github.com/jacoco/jacoco.git;pat
+ h="org.jacoco.agent";commitId=78d5eff856bbe6129f05012e40c13d1840e20598
+Export-Package: org.jacoco.agent;version="0.8.13"
+Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.5))"
+Tool: Bnd-7.0.0.202310060912
+

build/tmp/.cache/expanded/zip_9892ccb804f78c0637616b68610d363f/META-INF/maven/org.jacoco/org.jacoco.agent/pom.properties

@@ -0,0 +1,3 @@
+artifactId=org.jacoco.agent
+groupId=org.jacoco
+version=0.8.13

build/tmp/.cache/expanded/zip_9892ccb804f78c0637616b68610d363f/META-INF/maven/org.jacoco/org.jacoco.agent/pom.xml

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2009, 2025 Mountainminds GmbH & Co. KG and Contributors
+   This program and the accompanying materials are made available under
+   the terms of the Eclipse Public License 2.0 which is available at
+   http://www.eclipse.org/legal/epl-2.0
+
+   SPDX-License-Identifier: EPL-2.0
+
+   Contributors:
+      Evgeny Mandrikov - initial API and implementation
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.jacoco</groupId>
+    <artifactId>org.jacoco.build</artifactId>
+    <version>0.8.13</version>
+    <relativePath>../org.jacoco.build</relativePath>
+  </parent>
+
+  <artifactId>org.jacoco.agent</artifactId>
+
+  <name>JaCoCo :: Agent</name>
+  <description>JaCoCo Agent</description>
+
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>prepare-package</phase>
+            <goals>
+              <goal>copy</goal>
+            </goals>
+            <configuration>
+              <artifactItems>
+                <artifactItem>
+                  <groupId>${project.groupId}</groupId>
+                  <artifactId>org.jacoco.agent.rt</artifactId>
+                  <classifier>all</classifier>
+                  <version>${project.version}</version>
+                  <destFileName>jacocoagent.jar</destFileName>
+                </artifactItem>
+              </artifactItems>
+              <outputDirectory>${project.build.directory}/classes</outputDirectory>
+              <overWriteReleases>false</overWriteReleases>
+              <overWriteSnapshots>false</overWriteSnapshots>
+              <overWriteIfNewer>true</overWriteIfNewer>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>build-helper-maven-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>attach-artifacts</id>
+            <phase>package</phase>
+            <goals>
+              <goal>attach-artifact</goal>
+            </goals>
+            <configuration>
+              <artifacts>
+                <artifact>
+                  <file>${project.build.directory}/classes/jacocoagent.jar</file>
+                  <type>jar</type>
+                  <classifier>runtime</classifier>
+                </artifact>
+              </artifacts>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.felix</groupId>
+        <artifactId>maven-bundle-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>process-classes</phase>
+            <goals>
+              <goal>manifest</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <configuration>
+          <archive>
+            <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

build/tmp/.cache/expanded/zip_9892ccb804f78c0637616b68610d363f/about.html

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+<head>
+<title>About</title>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+
+<p>
+  2025/04/02
+</p>
+
+<h3>License</h3>
+
+<p>
+  All Content in this distribution is made available by Mountainminds GmbH &amp; Co.
+  KG, Munich. Unless otherwise indicated below, the Content is provided to you
+  under the terms and conditions of the Eclipse Public License Version 2.0
+  (&quot;EPL&quot;). A copy of the EPL is available at
+  <a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>.
+  For purposes of the EPL, "Program" will mean the Content.
+</p>
+
+<h3>Third Party Content</h3>
+
+<p>
+  The Content includes items that have been sourced from third parties as set
+  out below.
+</p>
+
+<h4>ASM</h4>
+
+<p>
+  <a href="https://asm.ow2.io/">ASM 9.8</a> is subject to the terms and
+  conditions of the following license:
+</p>
+
+<pre>
+ASM: a very small and fast Java bytecode manipulation framework
+Copyright (c) 2000-2011 INRIA, France Telecom
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holders nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+</pre>
+
+
+</body>
+</html>

build/tmp/jar/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

docker/compose.yml

@@ -1,19 +0,0 @@
-version: "3.9"
-
-services:
-  mysql:
-    image: mysql:8.0
-    container_name: mysql-db
-    restart: unless-stopped
-    environment:
-      MYSQL_ROOT_PASSWORD: root
-      MYSQL_DATABASE: sql7810540
-      MYSQL_USER: sql7810540
-      MYSQL_PASSWORD: mXdJCFtDZz
-    ports:
-      - "3306:3306"
-    volumes:
-      - mysql_data:/var/lib/mysql
-
-volumes:
-  mysql_data:

resources/sql/CountAllFieldsTask.sql

@@ -1 +0,0 @@
-SELECT COUNT(*) AS total FROM Task

resources/sql/CountAllFieldsWorker.sql

@@ -1 +0,0 @@
-SELECT COUNT(*) AS total FROM Worker

resources/sql/DeleteTaskTable.sql

@@ -1 +0,0 @@
-DELETE FROM Task WHERE taskid = ?

resources/sql/InsertTaskTable.sql

@@ -1 +0,0 @@
-INSERT INTO Task (taskid, name, description, workerid, taskstate) VALUES (?, ?, ?, ?, ?)

resources/sql/InsertWorkerTable.sql

@@ -1 +0,0 @@
-INSERT INTO Worker (workerid, name) VALUES (?, ?)

resources/sql/SelectAllTask.sql

@@ -1 +0,0 @@
-SELECT * FROM Task

resources/sql/SelectAllWorker.sql

@@ -1 +0,0 @@
-SELECT * FROM Worker

resources/sql/SelectTaskById.sql

@@ -1 +0,0 @@
-SELECT * FROM Task WHERE taskid = ? LIMIT 1

resources/sql/SelectTaskTable.sql

@@ -1 +0,0 @@
-SELECT * FROM Task WHERE workerid = ?

resources/sql/SelectWorkerById.sql

@@ -1 +0,0 @@
-SELECT * FROM Worker WHERE workerid = ? LIMIT 1

resources/sql/UpdateTaskTable.sql

@@ -1 +0,0 @@
-UPDATE Task SET name = ?, description = ?, taskstate = ? WHERE taskid = ?

resources/sql/UpdateWorkerTable.sql

@@ -1 +0,0 @@
-UPDATE Worker SET workerid = ?, name = ? WHERE workerid = ?

resources/sql/createTaskTable.sql

@@ -1,8 +0,0 @@
-CREATE TABLE Task (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    taskid INT,
-    name VARCHAR(255) NOT NULL,
-    description TEXT,
-    workerid INT,
-    taskstate BIT
-);

resources/sql/createWorkerTable.sql

@@ -1,5 +0,0 @@
-CREATE TABLE Worker (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    workerid INT,
-    name VARCHAR(255) NOT NULL
-);

src/main/java/hhn/temp/project/AssignmentManager.java

@@ -1,172 +1,12 @@
 package hhn.temp.project;
 
-import hhn.temp.project.provider.SimpleDatabaseManager;
+import java.util.ArrayList;
-
+import java.util.List;
-import java.sql.SQLException;
-import java.util.*;
 
 public class AssignmentManager {
-    private Map<Integer, Worker> workerMap;
+    List<Worker> workerList;
-    private Map<Integer, Task> taskMap;
-    private int workerIdCounter;
-    private int taskIdCounter;
-    private UserCommands userInterface;
-    private SimpleDatabaseManager database;
 
     public AssignmentManager() {
-        database = new SimpleDatabaseManager();
+        workerList = new ArrayList<>();
-        connect();
-        workerMap = new HashMap<>();
-        taskMap = new HashMap<>();
-        workerIdCounter = 1000;
-        taskIdCounter = 0;
-        sync();
-        userInterface = new UserCommands(this);
     }
-    private void connect() {
-        try {
-            database.connect();
-        } catch (SQLException e) {
-            System.err.println("Failed to connect to database");
-        }
-    }
-    private void sync() {
-        workerMap.clear();
-        taskMap.clear();
-        try {
-            Collection<Worker> workers = database.getWorkers();
-            if (workers != null) {
-                for (Worker worker : workers) {
-                    workerMap.put(worker.getId(),worker);
-                    if (worker.getId() > workerIdCounter) {
-                        workerIdCounter = worker.getId();
-                    }
-                }
-            }
-            Collection<Task> tasks = database.getTasks();
-            if (tasks != null) {
-                for (Task task : tasks) {
-                    taskMap.put(task.getTaskId(),task);
-                    if (task.getTaskId() > taskIdCounter) {
-                        taskIdCounter = task.getTaskId();
-                    }
-                }
-            }
-
-        } catch (SQLException e) {
-            System.err.println("Failed to sync");
-        }
-    }
-    public Map<Integer, Task> getTaskMap() {
-        return taskMap;
-    }
-    public Map<Integer, Worker> getWorkerMap() {return workerMap;}
-
-    public int createWorker(String name) {
-        sync();
-        Worker worker = new Worker(name, ++workerIdCounter);
-        workerMap.put(workerIdCounter, worker);
-        try {
-            database.saveWorker(worker);
-        } catch (SQLException e) {
-            System.err.println("Failed to save worker");
-        }
-        return workerIdCounter;
-    }
-    public void removeWorker(int workerId) {
-        if (!workerMap.containsKey(workerId)) {
-            throw new IllegalArgumentException("WorkerId must exist in order to remove it");
-        }
-        workerMap.remove(workerId);
-        try {
-            database.deleteWorker(workerId);
-        } catch (SQLException e) {
-            System.err.println("Failed to delete worker");
-        }
-    }
-    public int addTask(int workerId, String name, String description) {
-        if (!workerMap.containsKey(workerId) || name == null || description == null) {
-            throw new IllegalArgumentException("WorkerId must exist and name or description can't be null");
-        }
-        Task task = new Task(++taskIdCounter, workerId, name, description);
-        taskMap.put(taskIdCounter, task);
-        try {
-            database.saveTask(task);
-        } catch (SQLException e) {
-            System.err.println("Failed to save task");
-        }
-        return taskIdCounter;
-    }
-    public Task getTask(int taskId) {
-        if (!taskMap.containsKey(taskId)) {
-            throw new IllegalArgumentException("Task Id does not exist");
-        }
-        return taskMap.get(taskId);
-    }
-    public Worker getWorker(int workerId) {
-        if (!workerMap.containsKey(workerId)) {
-            throw new IllegalArgumentException("Worker Id does not exist");
-        }
-        return workerMap.get(workerId);
-    }
-    public void editTask(int workerId, int taskId, String name, String description) {
-        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
-            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
-        }
-        Task task = taskMap.get(taskId);
-        task.setName(name);
-        task.setDescription(description);
-        try {
-            database.updateTask(task.getTaskId(),task);
-        } catch (SQLException e) {
-            System.err.println("Failed to update Task");
-        }
-    }
-    public void removeTask(int taskId) {
-        if (!taskMap.containsKey(taskId)) {
-            throw new IllegalArgumentException("Task Id does not exist");
-        }
-        taskMap.remove(taskId);
-        try {
-            database.deleteTask(taskId);
-        } catch (SQLException e) {
-            System.err.println("Failed to remove task");
-        }
-    }
-    public void finishTask(int workerId, int taskId) {
-        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
-            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
-        }
-        Task task = taskMap.get(taskId);
-        task.setTaskState(TaskState.FINISHED);
-        try {
-            database.updateTask(taskId,task);
-        } catch (SQLException e) {
-            System.err.println("Failed to finish task");
-        }
-    }
-    public void unfinishTask(int workerId, int taskId) {
-        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
-            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
-        }
-        Task task = taskMap.get(taskId);
-        task.setTaskState(TaskState.IN_PROGRESS);
-        try {
-            database.updateTask(taskId,task);
-        } catch (SQLException e) {
-            System.err.println("Failed to finish task");
-        }
-    }
-    public UserCommands getUserCommands() {
-        return userInterface;
-    }
-
-    public void startCLI() {
-        userInterface.start();
-    }
-
-    public void stopCLI() {
-        userInterface.stop();
-    }
-
 }

src/main/java/hhn/temp/project/Main.java

@@ -1,10 +0,0 @@
-package hhn.temp.project;
-
-import java.util.Scanner;
-
-public class Main {
-    public static void main(String[] args) {
-        AssignmentManager manager = new AssignmentManager();
-        manager.startCLI();
-    }
-}

src/main/java/hhn/temp/project/Task.java

@@ -1,42 +1,4 @@
 package hhn.temp.project;
 
 public class Task {
-    private String name;
-    private String description;
-    private int taskId;
-    private int workerId;
-    private TaskState state;
-    public Task(int taskId, int workerId, String name, String description) {
-        this.name = name;
-        this.description = description;
-        this.taskId = taskId;
-        this.workerId = workerId;
-        this.state = TaskState.IN_PROGRESS;
-    }
-
-    public String getName() {
-        return name;
-    }
-    public void setName(String name) {
-        this.name = name;
-    }
-    public String getDescription() {
-        return description;
-    }
-    public void setDescription(String description) {
-        this.description = description;
-    }
-    public int getTaskId() {
-        return taskId;
-    }
-    public int getWorkerId() {
-        return workerId;
-    }
-    public void setTaskState(TaskState state) {
-        this.state = state;
-    }
-    public TaskState getTaskState() {
-        return state;
-    }
-
 }

src/main/java/hhn/temp/project/UserCommands.java

@@ -1,444 +0,0 @@
-package hhn.temp.project;
-
-import java.util.Scanner;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class UserCommands implements Runnable {
-    private Scanner scanner;
-    private AssignmentManager manager;
-    private Integer selectedTaskId = null;
-    private Integer selectedWorkerId = null;
-    private AtomicBoolean running = new AtomicBoolean(false);
-    private Thread cliThread;
-
-    private enum InputState {
-        MAIN_MENU,
-        TASK_SELECTED,
-        WORKER_SELECTED,
-        AWAITING_EDIT_INPUT,
-        AWAITING_CREATE_TASK_WORKER,
-        AWAITING_CREATE_TASK_NAME,
-        AWAITING_CREATE_TASK_DESC,
-        AWAITING_CREATE_WORKER_NAME,
-        AWAITING_TASK_SELECTION
-    }
-
-    private InputState currentState = InputState.MAIN_MENU;
-    private Integer tempWorkerId = null;
-    private String tempTaskName = null;
-
-    public UserCommands(AssignmentManager manager) {
-        this.manager = manager;
-    }
-
-    @Override
-    public void run() {
-        scanner = new Scanner(System.in);
-        running.set(true);
-
-        while (running.get()) {
-            printPrompt();
-            String input = scanner.nextLine().trim();
-
-            if ("exit".equalsIgnoreCase(input)) {
-                stop();
-                continue;
-            }
-
-            handleInput(input);
-        }
-        scanner.close();
-    }
-
-    public void start() {
-        if (cliThread == null || !cliThread.isAlive()) {
-            cliThread = new Thread(this, "CLI-Thread");
-            cliThread.start();
-        }
-    }
-
-    public void stop() {
-        running.set(false);
-        if (cliThread != null) {
-            cliThread.interrupt();
-        }
-    }
-
-    private void printPrompt() {
-        if (!running.get()) return;
-
-        switch (currentState) {
-            case MAIN_MENU:
-                System.out.println("Type '?' or 'help' for a list of commands");
-                break;
-            case TASK_SELECTED:
-                System.out.println("Task " + selectedTaskId + " selected. Commands: finish, unfinish, remove, edit, back");
-                break;
-            case WORKER_SELECTED:
-                if (selectedWorkerId != null) {
-                    System.out.println("Worker " + selectedWorkerId + " selected. Commands: remove, back");
-                } else {
-                    System.out.println("Enter worker ID to select (or 'back'):");
-                }
-                break;
-            case AWAITING_EDIT_INPUT:
-                System.out.println("Enter new name;description:");
-                break;
-            case AWAITING_CREATE_WORKER_NAME:
-                System.out.println("Enter worker name:");
-                break;
-            case AWAITING_CREATE_TASK_WORKER:
-                System.out.println("Enter worker ID:");
-                break;
-            case AWAITING_CREATE_TASK_NAME:
-                System.out.println("Enter task name:");
-                break;
-            case AWAITING_CREATE_TASK_DESC:
-                System.out.println("Enter task description:");
-                break;
-        }
-        System.out.print("> ");
-    }
-
-    public void handleInput(String input) {
-        if (input == null || input.isEmpty()) {
-            return;
-        }
-
-        if ("?".equals(input) || "help".equalsIgnoreCase(input)) {
-            showHelp();
-            return;
-        }
-
-        try {
-            switch (currentState) {
-                case MAIN_MENU:
-                    handleMainMenuInput(input);
-                    break;
-                case TASK_SELECTED:
-                    handleTaskSelectionInput(input);
-                    break;
-                case WORKER_SELECTED:
-                    handleWorkerSelectionInput(input);
-                    break;
-                case AWAITING_EDIT_INPUT:
-                    handleEditInput(input);
-                    break;
-                case AWAITING_CREATE_TASK_WORKER:
-                    handleCreateTaskWorkerInput(input);
-                    break;
-                case AWAITING_CREATE_TASK_NAME:
-                    handleCreateTaskNameInput(input);
-                    break;
-                case AWAITING_CREATE_TASK_DESC:
-                    handleCreateTaskDescInput(input);
-                    break;
-                case AWAITING_CREATE_WORKER_NAME:
-                    handleCreateWorkerNameInput(input);
-                    break;
-                case AWAITING_TASK_SELECTION:
-                    handleTaskIdInput(input);
-                    break;
-            }
-        } catch (Exception e) {
-            System.out.println("Error: " + e.getMessage());
-            resetToMainMenu();
-        }
-    }
-
-    private void showHelp() {
-        System.out.println("=== Available Commands ===");
-        System.out.println("General:");
-        System.out.println("  help, ? - Show this help");
-        System.out.println("  exit - Exit the program");
-        System.out.println("  createworker - Create a new worker");
-        System.out.println("  createtask - Create a new task");
-        System.out.println("  selecttask - Select a task to work with");
-        System.out.println("  listworkers - List all workers");
-        System.out.println("  listtasks - List all tasks with status");
-        System.out.println("  listfinished - List only finished tasks");
-        System.out.println("  listunfinished - List only unfinished tasks");
-
-        System.out.println("\nWhen a task is selected:");
-        System.out.println("  finish - Mark task as finished");
-        System.out.println("  unfinish - Mark task as unfinished");
-        System.out.println("  remove - Remove the task");
-        System.out.println("  edit - Edit task name and description");
-        System.out.println("  back - Return to main menu");
-
-        System.out.println("\nWhen a worker is selected:");
-        System.out.println("  remove - Remove the worker");
-        System.out.println("  back - Return to main menu");
-    }
-
-    private void handleMainMenuInput(String input) {
-        switch (input.toLowerCase()) {
-            case "createworker":
-                System.out.println("Enter worker name:");
-                currentState = InputState.AWAITING_CREATE_WORKER_NAME;
-                break;
-
-            case "createtask":
-                System.out.println("Enter worker ID:");
-                currentState = InputState.AWAITING_CREATE_TASK_WORKER;
-                break;
-
-            case "selecttask":
-                System.out.println("Enter task ID:");
-                currentState = InputState.AWAITING_TASK_SELECTION;
-                break;
-
-            case "listworkers":
-                listWorkers();
-                break;
-
-            case "listtasks":
-                listAllTasks();
-                break;
-
-            case "listfinished":
-                listTasksByStatus(TaskState.FINISHED);
-                break;
-
-            case "listunfinished":
-                listTasksByStatus(TaskState.IN_PROGRESS);
-                break;
-
-            default:
-                System.out.println("Unknown command. Type 'help' for available commands.");
-        }
-    }
-
-    private void listWorkers() {
-        System.out.println("\nAvailable workers:");
-        if (manager.getWorkerMap().isEmpty()) {
-            System.out.println("  No workers found.");
-        } else {
-            for (Worker w : manager.getWorkerMap().values()) {
-                System.out.println("  " + w.getId() + ": " + w.getName());
-            }
-        }
-        System.out.println();
-    }
-
-    private void listAllTasks() {
-        System.out.println("\nAll tasks:");
-        if (manager.getTaskMap().isEmpty()) {
-            System.out.println("  No tasks found.");
-        } else {
-            for (Task task : manager.getTaskMap().values()) {
-                Worker worker = manager.getWorker(task.getWorkerId());
-                String status = task.getTaskState() == TaskState.FINISHED ? "[FINISHED]" : "[IN PROGRESS]";
-                System.out.println(String.format("  %d: %s - %s (Worker: %d - %s)",
-                        task.getTaskId(), status, task.getName(),
-                        worker.getId(), worker.getName()));
-            }
-        }
-        System.out.println();
-    }
-
-    private void listTasksByStatus(TaskState status) {
-        System.out.println("\nTasks with status: " + status);
-        boolean found = false;
-
-        for (Task task : manager.getTaskMap().values()) {
-            if (task.getTaskState() == status) {
-                Worker worker = manager.getWorker(task.getWorkerId());
-                System.out.println(String.format("  %d: %s (Worker: %d - %s)",
-                        task.getTaskId(), task.getName(),
-                        worker.getId(), worker.getName()));
-                found = true;
-            }
-        }
-
-        if (!found) {
-            System.out.println("  No tasks found with this status.");
-        }
-        System.out.println();
-    }
-
-    private void handleWorkerSelectionInput(String input) {
-        if ("back".equalsIgnoreCase(input)) {
-            resetToMainMenu();
-            return;
-        }
-
-        try {
-            int workerId = Integer.parseInt(input.trim());
-            Worker worker = manager.getWorker(workerId);
-            if (worker != null) {
-                selectedWorkerId = workerId;
-                System.out.println("Worker " + workerId + " (" + worker.getName() + ") selected");
-                System.out.println("Commands: remove, back");
-            } else {
-                System.out.println("Worker not found. Please enter a valid worker ID:");
-            }
-        } catch (NumberFormatException e) {
-            if (selectedWorkerId != null) {
-                handleWorkerCommand(input);
-            } else {
-                System.out.println("Invalid input. Please enter a worker ID or 'back':");
-            }
-        }
-    }
-
-    private void handleWorkerCommand(String input) {
-        switch (input.toLowerCase()) {
-            case "remove":
-                manager.removeWorker(selectedWorkerId);
-                System.out.println("Worker removed");
-                resetToMainMenu();
-                break;
-
-            case "back":
-                resetToMainMenu();
-                break;
-
-            default:
-                System.out.println("Unknown command. Available commands: remove, back");
-        }
-    }
-
-    private void handleCreateWorkerNameInput(String input) {
-        int workerId = manager.createWorker(input.trim());
-        System.out.println("Created worker with ID: " + workerId);
-        resetToMainMenu();
-    }
-    private void handleTaskIdInput(String input) {
-        if ("back".equalsIgnoreCase(input)) {
-            resetToMainMenu();
-            return;
-        }
-
-        try {
-            int taskId = Integer.parseInt(input.trim());
-            Task task = manager.getTask(taskId);
-            if (task != null) {
-                selectedTaskId = taskId;
-                currentState = InputState.TASK_SELECTED;
-                System.out.println("Task " + taskId + " (" + task.getName() + ") selected");
-                System.out.println("Commands: finish, unfinish, remove, edit, back");
-            } else {
-                System.out.println("Task not found. Please enter a valid task ID:");
-            }
-        } catch (NumberFormatException e) {
-            System.out.println("Invalid input. Please enter a task ID or 'back':");
-        }
-    }
-
-
-    private void handleCreateTaskWorkerInput(String input) {
-        try {
-            tempWorkerId = Integer.parseInt(input.trim());
-            System.out.println("Enter task name:");
-            currentState = InputState.AWAITING_CREATE_TASK_NAME;
-        } catch (NumberFormatException e) {
-            System.out.println("Invalid worker ID. Please enter a number:");
-        }
-    }
-
-    private void handleCreateTaskNameInput(String input) {
-        tempTaskName = input.trim();
-        System.out.println("Enter task description:");
-        currentState = InputState.AWAITING_CREATE_TASK_DESC;
-    }
-
-    private void handleCreateTaskDescInput(String input) {
-        int taskId = manager.addTask(tempWorkerId, tempTaskName, input.trim());
-        System.out.println("Created task with ID: " + taskId);
-        resetToMainMenu();
-    }
-
-    private void resetToMainMenu() {
-        currentState = InputState.MAIN_MENU;
-        selectedTaskId = null;
-        selectedWorkerId = null;
-        tempWorkerId = null;
-        tempTaskName = null;
-    }
-
-    private void handleTaskSelectionInput(String input) {
-        if ("back".equalsIgnoreCase(input)) {
-            resetToMainMenu();
-            return;
-        }
-
-        try {
-            int taskId = Integer.parseInt(input.trim());
-            Task task = manager.getTask(taskId);
-            if (task != null) {
-                selectedTaskId = taskId;
-                currentState = InputState.TASK_SELECTED;
-                System.out.println("Task " + taskId + " (" + task.getName() + ") selected");
-                System.out.println("Commands: finish, unfinish, remove, edit, back");
-            } else {
-                System.out.println("Task not found. Please enter a valid task ID:");
-            }
-        } catch (NumberFormatException e) {
-            if (selectedTaskId != null) {
-                handleTaskCommand(input);
-            } else {
-                System.out.println("Invalid input. Please enter a task ID or 'back':");
-            }
-        }
-    }
-
-    private void handleTaskCommand(String input) {
-        switch (input.toLowerCase()) {
-            case "finish":
-                manager.finishTask(manager.getTask(selectedTaskId).getWorkerId(),selectedTaskId);
-                System.out.println("Task marked as finished");
-                break;
-
-            case "unfinish":
-                manager.unfinishTask(manager.getTask(selectedTaskId).getWorkerId(),selectedTaskId);
-                System.out.println("Task marked as unfinished");
-                break;
-
-            case "remove":
-                manager.removeTask(selectedTaskId);
-                System.out.println("Task removed");
-                resetToMainMenu();
-                break;
-
-            case "edit":
-                System.out.println("Enter new name;description:");
-                currentState = InputState.AWAITING_EDIT_INPUT;
-                break;
-
-            case "back":
-                resetToMainMenu();
-                break;
-
-            default:
-                System.out.println("Unknown command. Type 'help' for available commands.");
-        }
-    }
-
-    private void handleEditInput(String input) {
-        String[] parts = input.split(";", 2);
-        if (parts.length == 2) {
-            manager.editTask(manager.getTask(selectedTaskId).getWorkerId(), selectedTaskId, parts[0], parts[1]);
-            System.out.println("Task edited");
-        } else {
-            System.out.println("Invalid format. Use: name;description");
-            System.out.println("Please try again:");
-            return;
-        }
-        currentState = InputState.TASK_SELECTED;
-    }
-
-    public Scanner getScanner() {
-        return scanner;
-    }
-
-    //only for testing
-    public void setScanner(Scanner scanner) {
-        this.scanner = scanner;
-    }
-
-    //only for testing
-    public boolean isRunning() {
-        return running.get();
-    }
-}

src/main/java/hhn/temp/project/Worker.java

@@ -1,17 +1,4 @@
 package hhn.temp.project;
 
 public class Worker {
-    private String name;
-    private int workerId;
-    public Worker(String name, int workerId) {
-        this.name = name;
-        this.workerId = workerId;
-    }
-
-    public String getName() {
-        return name;
-    }
-    public int getId() {
-        return workerId;
-    }
 }

src/main/java/hhn/temp/project/provider/Database.java

@@ -1,29 +1,5 @@
 package hhn.temp.project.provider;
 
-import java.io.IOException;
-import java.nio.file.Path;
-import java.sql.SQLException;
-
-/**
- * A database interface with basic database connectivity
- * @author Riley Schneider
- */
 public interface Database {
-  /**
+  public boolean connect();
-   * Creates a connection to the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void connect() throws SQLException;
-
-  /**
-   * Closes a connection to the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void close() throws SQLException;
-
-  /**
-   * Clears the entire tables in the database and reset primary key counter to each table
-   * @throws SQLException Thrown if database error occurs
-   */
-  void clearDatabase() throws SQLException;
 }

src/main/java/hhn/temp/project/provider/DatabaseManager.java

@@ -1,115 +1,10 @@
 package hhn.temp.project.provider;
 
-import hhn.temp.project.Task;
-import hhn.temp.project.Worker;
-
-import java.sql.SQLException;
 import java.util.Collection;
 
-/**
+public interface DatabaseManager<E> extends Database {
- * Simple Database Manager to handle simple command such as insertion, deletion, updating of Task and Worker objects.
+  public void saveObjects(Collection<E> objects);
- * @author Riley Schneider
+  public Collection<E> getObjects();
- */
+  public void saveObject(E object);
-public interface DatabaseManager extends Database {
+  public E getObject(int id);
-  /**
-   * Saves a Task object into the database
-   * @param task Task to be saved into the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void saveTask(Task task) throws SQLException;
-
-  /**
-   * Saves a collection of Task objects into the database
-   * @param tasks Tasks to be saved into the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void saveTasks(Collection<Task> tasks) throws SQLException;
-
-  /**
-   * Saves a Worker object into the database
-   * @param worker Worker to be saved into the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void saveWorker(Worker worker) throws SQLException;
-
-  /**
-   * Saves a collection Worker objects into the database
-   * @param workers Workers to be saved into the database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void saveWorkers(Collection<Worker> workers) throws SQLException;
-
-  /**
-   * Updates a Task object that already exists in the database
-   * @param taskId The ID of the given task
-   * @param newTaskObject The new Task object that will overwrite the existent task on database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void updateTask(int taskId, Task newTaskObject) throws  SQLException;
-
-  /**
-   * Updates a Worker object that already exists in the database
-   * @param workerId The ID of the given worker
-   * @param newWorkerObject The new Worker object that will overwrite the existent task on database
-   * @throws SQLException Thrown if database error occurs
-   */
-  void updateWorker(int workerId, Worker newWorkerObject) throws  SQLException;
-
-  /**
-   * Deletes a task from the database
-   * @param taskId The ID of the given task that needs to be deleted
-   * @throws SQLException Thrown if database error occurs
-   */
-  void deleteTask(int taskId) throws  SQLException;
-
-  /**
-   * Deletes a worker from the database
-   * @param workerId The ID of the given worker that needs to be deleted
-   * @throws SQLException Thrown if database error occurs
-   */
-  void deleteWorker(int workerId) throws  SQLException;
-
-  /**
-   * Gets a collection of all tasks available in the database
-   * @return A collection of tasks (empty if no task available)
-   * @throws SQLException Thrown if database error occurs
-   */
-  Collection<Task> getTasks() throws SQLException;
-
-  /**
-   * Gets a collection of all workers available in the database
-   * @return A collection of workers (empty if no task available)
-   * @throws SQLException Thrown if database error occurs
-   */
-  Collection<Worker> getWorkers() throws SQLException;
-
-  /**
-   * Gets a task given by its ID from the database
-   * @param taskId The task ID
-   * @return A task from the database (NULL if no task found)
-   * @throws SQLException Thrown if database error occurs
-   */
-  Task getTaskByTaskId(int taskId) throws SQLException;
-
-  /**
-   * Gets a worker given by its ID from the database
-   * @param workerId The worker ID
-   * @return A worker from the database (NULL if no worker found)
-   * @throws SQLException Thrown if database error occurs
-   */
-  Worker getWorkerByWorkerId(int workerId) throws SQLException;
-
-  /**
-   * Gets the total number of available tasks in the database.
-   * @return The total number of tasks (0 = zero entries; -1 = error)
-   * @throws SQLException Thrown if database error occurs
-   */
-  int getTotalNumberOfTasks() throws  SQLException;
-
-  /**
-   * Gets the total number of available workers in the database.
-   * @return The total number of workers (0 = zero entries; -1 = error)
-   * @throws SQLException Thrown if database error occurs
-   */
-  int getTotalNumberOfWorkers() throws  SQLException;
 }

src/main/java/hhn/temp/project/provider/SimpleDatabaseManager.java

@@ -1,403 +0,0 @@
-package hhn.temp.project.provider;
-
-import hhn.temp.project.Task;
-import hhn.temp.project.TaskState;
-import hhn.temp.project.Worker;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.*;
-import java.util.*;
-
-public class SimpleDatabaseManager implements DatabaseManager {
-
-  private Connection connection;
-
-  private final static Path INSERT_TASK = Path.of("resources/sql/InsertTaskTable.sql");
-  private final static Path DELETE_TASK = Path.of("resources/sql/DeleteTaskTable.sql");
-  private final static Path SELECT_TASK = Path.of("resources/sql/SelectTaskTable.sql");
-  private final static Path UPDATE_TASK = Path.of("resources/sql/UpdateTaskTable.sql");
-  private final static Path COUNT_ALL_TASK = Path.of("resources/sql/CountAllFieldsTask.sql");
-  private final static Path SELECT_ALL_TASK = Path.of("resources/sql/SelectAllTask.sql");
-  private final static Path SELECT_TASK_BY_ID = Path.of("resources/sql/SelectTaskById.sql");
-  private final static Path INSERT_WORKER = Path.of("resources/sql/InsertWorkerTable.sql");
-  private final static Path DELETE_WORKER = Path.of("resources/sql/DeleteWorkerTable.sql");
-  private final static Path SELECT_WORKER = Path.of("resources/sql/SelectWorkerTable.sql");
-  private final static Path UPDATE_WORKER = Path.of("resources/sql/UpdateWorkerTable.sql");
-  private final static Path COUNT_ALL_WORKER = Path.of("resources/sql/CountAllFieldsWorker.sql");
-  private final static Path SELECT_ALL_WORKER = Path.of("resources/sql/SelectAllWorker.sql");
-  private final static Path SELECT_WORKER_BY_ID = Path.of("resources/sql/SelectWorkerById.sql");
-
-  public enum QueryMode {
-    INSERT_TASK,
-    SELECT_TASK,
-    UPDATE_TASK,
-    DELETE_TASK,
-    SELECT_ALL_TASK,
-    SELECT_TASK_BY_ID,
-    COUNT_ALL_TASK,
-    INSERT_WORKER,
-    SELECT_WORKER,
-    UPDATE_WORKER,
-    DELETE_WORKER,
-    COUNT_ALL_WORKER,
-    SELECT_ALL_WORKER,
-    SELECT_WORKER_BY_ID,
-  }
-
-  private String loadFile(QueryMode queryMode) throws IOException {
-    switch (queryMode) {
-      case INSERT_TASK -> {
-        return Files.readString(INSERT_TASK);
-      }
-      case SELECT_TASK -> {
-        return Files.readString(SELECT_TASK);
-      }
-      case DELETE_TASK -> {
-        return Files.readString(DELETE_TASK);
-      }
-      case UPDATE_TASK -> {
-        return Files.readString(UPDATE_TASK);
-      }
-      case COUNT_ALL_TASK -> {
-        return Files.readString(COUNT_ALL_TASK);
-      }
-      case SELECT_ALL_TASK -> {
-        return Files.readString(SELECT_ALL_TASK);
-      }
-      case SELECT_TASK_BY_ID -> {
-        return Files.readString(SELECT_TASK_BY_ID);
-      }
-      case INSERT_WORKER -> {
-        return Files.readString(INSERT_WORKER);
-      }
-      case SELECT_WORKER -> {
-        return Files.readString(SELECT_WORKER);
-      }
-      case DELETE_WORKER -> {
-        return Files.readString(DELETE_WORKER);
-      }
-      case UPDATE_WORKER -> {
-        return Files.readString(UPDATE_WORKER);
-      }
-      case COUNT_ALL_WORKER -> {
-        return Files.readString(COUNT_ALL_WORKER);
-      }
-      case SELECT_ALL_WORKER -> {
-        return Files.readString(SELECT_ALL_WORKER);
-      }
-      case SELECT_WORKER_BY_ID -> {
-        return Files.readString(SELECT_WORKER_BY_ID);
-      }
-      default -> {
-        return "";
-      }
-    }
-  }
-
-  private TaskState integerToTaskState(final int in) {
-    return in == 1 ? TaskState.FINISHED : TaskState.IN_PROGRESS;
-  }
-
-  private int taskStateToInteger(final TaskState taskState) {
-    return taskState == TaskState.FINISHED ? 1 : 0;
-  }
-
-  @Override
-  public void saveTask(final Task task) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.INSERT_TASK);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setInt(1, task.getTaskId());
-      preparedStatement.setString(2, task.getName());
-      preparedStatement.setString(3, task.getDescription());
-      preparedStatement.setInt(4, task.getWorkerId());
-      preparedStatement.setInt(5, taskStateToInteger(task.getTaskState()));
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public void saveTasks(final Collection<Task> tasks) throws SQLException {
-    for (Task task : tasks) {
-      saveTask(task);
-    }
-  }
-
-  @Override
-  public void saveWorker(final Worker worker) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.INSERT_WORKER);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setInt(1, worker.getId());
-      preparedStatement.setString(2, worker.getName());
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public void saveWorkers(final Collection<Worker> workers) throws SQLException {
-    for (Worker worker : workers) {
-      saveWorker(worker);
-    }
-  }
-
-  @Override
-  public void updateTask(final int taskId, final Task newTaskObject) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.UPDATE_TASK);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setString(1, newTaskObject.getName());
-      preparedStatement.setString(2, newTaskObject.getDescription());
-      preparedStatement.setInt(3, taskStateToInteger(newTaskObject.getTaskState()));
-      preparedStatement.setInt(4, taskId);
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public void updateWorker(final int workerId, final Worker newWorkerObject) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.UPDATE_WORKER);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setInt(1, newWorkerObject.getId());
-      preparedStatement.setString(2, newWorkerObject.getName());
-      preparedStatement.setInt(3, workerId);
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public void deleteTask(final int taskId) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.DELETE_TASK);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setInt(1, taskId);
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public void deleteWorker(final int workerId) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.DELETE_WORKER);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return;
-    }
-    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
-      preparedStatement.setInt(1, workerId);
-      preparedStatement.execute();
-    }
-  }
-
-  @Override
-  public Collection<Task> getTasks() throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.SELECT_ALL_TASK);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return null;
-    }
-
-    Collection<Task> tasks = new ArrayList<>();
-
-    try (Statement statement = connection.createStatement();
-         ResultSet rs = statement.executeQuery(query);) {
-
-      while (rs.next()) {
-            int taskId = rs.getInt("taskid");
-            String name = rs.getString("name");
-            String description = rs.getString("description");
-            int workerId = rs.getInt("workerid");
-            TaskState taskState = integerToTaskState(rs.getInt("taskstate"));
-
-            Task task = new Task(taskId, workerId, name, description);
-            task.setTaskState(taskState);
-
-            tasks.add(task);
-      }
-
-    }
-
-    return tasks;
-  }
-
-  @Override
-  public Collection<Worker> getWorkers() throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.SELECT_ALL_WORKER);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return null;
-    }
-
-    Collection<Worker> workers = new ArrayList<>();
-
-    try (Statement statement = connection.createStatement();
-         ResultSet rs = statement.executeQuery(query);) {
-
-      while (rs.next()) {
-        int workerId = rs.getInt("workerid");
-        String name = rs.getString("name");
-
-        Worker worker = new Worker(name, workerId);
-
-        workers.add(worker);
-      }
-
-    }
-
-    return workers;
-  }
-
-  @Override
-  public Task getTaskByTaskId(final int taskId) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.SELECT_TASK_BY_ID);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return null;
-    }
-
-    try (PreparedStatement statement = connection.prepareStatement(query);) {
-
-      statement.setInt(1, taskId);
-
-      ResultSet rs = statement.executeQuery();
-
-      while (rs.next()) {
-        int taskId1 = rs.getInt("taskid");
-        String name = rs.getString("name");
-        String description = rs.getString("description");
-        int workerId = rs.getInt("workerid");
-        TaskState taskState = integerToTaskState(rs.getInt("taskstate"));
-
-        Task task = new Task(taskId1, workerId, name, description);
-        task.setTaskState(taskState);
-
-        return task;
-      }
-
-    }
-
-    return null;
-  }
-
-  @Override
-  public Worker getWorkerByWorkerId(final int workerId) throws SQLException {
-    String query;
-    try {
-      query = loadFile(QueryMode.SELECT_WORKER_BY_ID);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return null;
-    }
-
-    try (PreparedStatement statement = connection.prepareStatement(query);) {
-
-      statement.setInt(1, workerId);
-
-      ResultSet rs = statement.executeQuery();
-
-      while (rs.next()) {
-        int workerId1 = rs.getInt("workerid");
-        String name = rs.getString("name");
-
-        Worker worker = new Worker(name, workerId1);
-
-        return worker;
-      }
-
-    }
-
-    return null;
-  }
-
-  @Override
-  public int getTotalNumberOfTasks() throws SQLException {
-    String query = "";
-    try {
-      query = loadFile(QueryMode.COUNT_ALL_TASK);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return -1;
-    }
-    try (Statement statement = connection.createStatement();
-         ResultSet rs = statement.executeQuery(query);) {
-
-      if (rs.next()) {
-        return rs.getInt("total");
-      }
-    }
-
-    return 0;
-  }
-
-  @Override
-  public int getTotalNumberOfWorkers() throws SQLException {
-    String query = "";
-    try {
-      query = loadFile(QueryMode.COUNT_ALL_WORKER);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return -1;
-    }
-    try (Statement statement = connection.createStatement();
-         ResultSet rs = statement.executeQuery(query);) {
-
-      if (rs.next()) {
-        return rs.getInt("total");
-      }
-    }
-
-    return 0;
-  }
-
-  public void clearDatabase() throws SQLException {
-    try (Statement statement = connection.createStatement()) {
-      statement.execute("TRUNCATE TABLE Task");
-      statement.execute("TRUNCATE TABLE Worker");
-    }
-  }
-
-  @Override
-  public void connect() throws SQLException {
-    connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/sql7810540?user=sql7810540&password=mXdJCFtDZz");
-  }
-
-  @Override
-  public void close() throws SQLException {
-    connection.close();
-  }
-}

test/hhn/temp/project/BadCasesTest.java

@@ -4,7 +4,8 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class BadCasesTest {
     AssignmentManager manager;
@@ -18,54 +19,20 @@ public class BadCasesTest {
     @DisplayName("Assert that added tasks can't be Null")
     public void assertNewTasksAreNotNull() {
         int workerId = manager.createWorker("Alfred");
-        assertThrows(IllegalArgumentException.class, () -> manager.addTask(workerId, null, null));
+        assertThrows(manager.addTask(workerId, null, null) instanceof IllegalArgumentException);
     }
     @Test
     @DisplayName("Assert List isn't empty after adding a task")
     public void assertListNowEmptyAfterAdd() {
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        assertFalse(manager.getTaskMap().isEmpty());
+        assertTrue(manager.getTaskList().size >= 1);
     }
     @Test
     @DisplayName("Assert only existing tasks can be edited")
     public void assertEditOnlyExistingTasks() {
         int workerId = manager.createWorker("Alfred");
-        assertThrows(IllegalArgumentException.class, () -> manager.editTask(workerId, 99969, "I", "am Illegal"));
+        assertThrows(manager.editTask(workerId, 99969, "I", "am Illegal") instanceof IllegalArgumentException);
-        assertThrows(IllegalArgumentException.class, () -> manager.editTask(22200, 99969, "I", "am Illegal"));
-    }
-    @Test
-    @DisplayName("Assert Add Task is programmed defensively")
-    public void assertAddTaskOnlyAcceptsValidParameters() {
-        int workerId = manager.createWorker("Alfred");
-        assertThrows(IllegalArgumentException.class, () -> manager.addTask( 20203,"I", "am Illegal"));
-        assertThrows(IllegalArgumentException.class, () -> manager.addTask( workerId,null, null));
-    }
-    @Test
-    @DisplayName("Assert that Remove Task is programmed defensively")
-    public void assertRemoveTaskOnlyAcceptsValidParameters() {
-        assertThrows(IllegalArgumentException.class, () -> manager.removeTask(20320));
-    }
-    @Test
-    @DisplayName("Assert that un-/finishing a Task only works with valid parameters")
-    public void assertTaskStateChangesOnlyAcceptsValidParameters() {
-        assertThrows(IllegalArgumentException.class, () -> manager.finishTask(20405, 21034));
-        assertThrows(IllegalArgumentException.class, () -> manager.unfinishTask(20405, 21034));
-    }
-    @Test
-    @DisplayName("Assert that removing a non-existent worker throws an Exception")
-    public void assertRemovingNonExistentWorkerFails() {
-        assertThrows(IllegalArgumentException.class, () -> manager.removeWorker(34054));
-    }
-    @Test
-    @DisplayName("Assert non-existent commands are recognized as such")
-    public void assertInvalidCommandsDontCrash() {
-        int workerId = manager.createWorker("Alfred");
-        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        try {
-            manager.getUserCommands().handleInput("baum");
-        } catch (Exception e) {
-            fail("Should not crash just because a command is invalid");
-        }
     }
+
 }

test/hhn/temp/project/DatabaseBadCasesTest.java

@@ -1,42 +0,0 @@
-package hhn.temp.project;
-
-import hhn.temp.project.provider.DatabaseManager;
-import hhn.temp.project.provider.SimpleDatabaseManager;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import java.sql.SQLException;
-
-public class DatabaseBadCasesTest {
-
-  private DatabaseManager databaseManager;
-
-  @BeforeEach
-  public void setup() throws SQLException {
-    databaseManager = new SimpleDatabaseManager();
-    databaseManager.connect();
-    databaseManager.clearDatabase();
-  }
-
-  @Test
-  @DisplayName("Inserting Tasks with the same ID")
-  public void insertTasksWithTheSameId() throws SQLException {
-    Task task = new Task(10, 10, "ABC", "XYZ");
-    Task taskFaker = new Task(10, 5, "ABC!", "XYZ!");
-
-    databaseManager.saveTask(task);
-
-    databaseManager.saveTask(taskFaker);
-  }
-
-  @Test
-  @DisplayName("Inserting Workers with the same ID")
-  public void insertWorkersWithTheSameId() throws SQLException {
-    Worker worker = new Worker("Worker-1", 1);
-    Worker workerFaker = new Worker("Worker-100", 1);
-
-    databaseManager.saveWorker(worker);
-
-    databaseManager.saveWorker(workerFaker);
-  }
-}

test/hhn/temp/project/DatabaseGoodCasesTest.java

@@ -1,83 +0,0 @@
-package hhn.temp.project;
-
-import hhn.temp.project.provider.SimpleDatabaseManager;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-import java.sql.SQLException;
-import java.util.Collection;
-import java.util.List;
-
-public class DatabaseGoodCasesTest {
-
-  private SimpleDatabaseManager databaseManager;
-
-  @BeforeEach
-  public void setup() throws SQLException {
-    databaseManager = new SimpleDatabaseManager();
-    databaseManager.connect();
-    databaseManager.clearDatabase();
-  }
-
-  @Test
-  @DisplayName("Inserting test task into the database and receiving back the same test task")
-  public void insertTaskAndReceiveItBackTest() throws SQLException {
-    Task task = new Task(123, 10, "Hello World", "Doing Something, hell yeah!");
-
-    databaseManager.saveTask(task);
-
-    Task reTask = databaseManager.getTaskByTaskId(task.getTaskId());
-
-    assertNotNull(reTask);
-    assertEquals(task.getTaskId(), reTask.getTaskId());
-    assertEquals(task.getDescription(), reTask.getDescription());
-    assertEquals(task.getName(), reTask.getName());
-    assertEquals(task.getWorkerId(), reTask.getWorkerId());
-
-    assertEquals(1, databaseManager.getTotalNumberOfTasks());
-  }
-
-  @Test
-  @DisplayName("Inserting test worker into the database and receiving back the same test worker")
-  public void insertWorkerAndReceivedItBackTest() throws SQLException {
-    Worker worker = new Worker("Worker-01", 12345678);
-
-    databaseManager.saveWorker(worker);
-
-    Worker reWorker = databaseManager.getWorkerByWorkerId(worker.getId());
-
-    assertNotNull(reWorker);
-
-    assertEquals(worker.getId(), reWorker.getId());
-    assertEquals(worker.getName(), reWorker.getName());
-  }
-
-  @Test
-  @DisplayName("Clearing the database (Task and Worker) test")
-  public void clearDatabaseTest() throws SQLException, InterruptedException {
-    Task task1 = new Task(10, 5, "Hello", "World");
-    Task task2 = new Task(9, 4, "Hochschule", "Heilbronn");
-    Task task3 = new Task(8, 9, "Gangnam", "Style");
-    Collection<Task> tasks = List.of(task1, task2, task3);
-
-    Worker worker1 = new Worker("ABC", 2);
-    Worker worker2 = new Worker("XYZ", 9);
-    Collection<Worker> workers = List.of(worker1, worker2);
-
-    databaseManager.saveTasks(tasks);
-    databaseManager.saveWorkers(workers);
-
-    Thread.sleep(500);
-
-    assertEquals(tasks.size(), databaseManager.getTotalNumberOfTasks());
-    assertEquals(workers.size(), databaseManager.getTotalNumberOfWorkers());
-
-    databaseManager.clearDatabase();
-
-    assertEquals(0, databaseManager.getTotalNumberOfTasks());
-    assertEquals(0, databaseManager.getTotalNumberOfWorkers());
-  }
-}

test/hhn/temp/project/GoodCasesTest.java

@@ -4,8 +4,6 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-import java.util.Scanner;
-
 import static org.junit.jupiter.api.Assertions.*;
 
 public class GoodCasesTest {
@@ -15,141 +13,58 @@ public class GoodCasesTest {
     public void setup() {
         manager = new AssignmentManager();
     }
-
     @Test
     @DisplayName("Assert that a Worker can add a Task")
     public void assertWorkerCanAddTask() {
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
         assertNotNull(manager.getTask(taskId));
-        assertEquals("Run", manager.getTask(taskId).getName());
+        assertEquals(manager.getTask(taskId).getName(), "Run");
     }
 
     @Test
     @DisplayName("Assert that added Tasks are added to the List")
     public void assertTasksShowInList() {
-        int sizeCount = manager.getTaskMap().size();
+        int sizeCount = manager.getTaskList().size();
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        assertEquals(sizeCount + 1, manager.getTaskMap().size());
+        assertEquals(sizeCount + 1, manager.getTaskList().size);
     }
-
     @Test
     @DisplayName("Assert existing Tasks can be edited")
     public void assertExistingTasksCanBeEdited() {
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
         manager.editTask(workerId, taskId, "Walk", "Walk 3 Miles");
-        assertEquals("Walk", manager.getTask(taskId).getName());
+        assertEquals(manager.getTask(taskId).getName(), "Walk");
-        assertEquals("Walk 3 Miles", manager.getTask(taskId).getDescription());
+        assertEquals(manager.getTask(taskId).getDescription(), "Walk 3 Miles");
     }
 
     @Test
     @DisplayName("Assert that Worker can remove Task")
     public void assertWorkerCanRemoveOwnTask() {
-        int sizeCount = manager.getTaskMap().size();
+        int sizeCount = manager.getTaskList().size();
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        assertEquals(sizeCount + 1, manager.getTaskMap().size());
+        assertEquals(sizeCount + 1, manager.getTaskList().size);
         manager.removeTask(taskId);
-        assertEquals(sizeCount, manager.getTaskMap().size());
+        assertEquals(sizeCount - 1, manager.getTaskList().size);
     }
-
     @Test
     @DisplayName("Assert deleted Tasks no longer show up in the List")
     public void assertDeletedTasksDisappear() {
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
         manager.removeTask(taskId);
-        assertThrows(IllegalArgumentException.class, () -> manager.getTask(taskId));
+        assertThrows(manager.getTask(taskId) instanceof  IllegalArgumentException);
     }
-
     @Test
     @DisplayName("Check Getters")
     public void assertGettersWorkCorrectly() {
         int workerId = manager.createWorker("Alfred");
-        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertEquals(manager.workerMap.get(workerId).getName(), "Alfred");
-        assertEquals("Alfred", manager.getWorkerMap().get(workerId).getName());
         //This one may be somewhat nonsensical, but it ensures the getId works so one may iterate over the workerMap
-        assertEquals(manager.getWorkerMap().get(workerId).getId(), workerId);
+        assertEquals(manager.workerMap.get(workerId).getId(), workerId);
-        assertEquals(manager.getTask(taskId).getTaskId(), taskId);
-        assertEquals(manager.getTask(taskId).getWorkerId(), workerId);
-
     }
 
-    @Test
-    @DisplayName("Assert that Task State is actually changed when submitted as finished")
-    public void assertTaskStateChanges() {
-        int workerId = manager.createWorker("Alfred");
-        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        manager.finishTask(workerId, taskId);
-        assertSame(TaskState.FINISHED, manager.getTask(taskId).getTaskState());
-        manager.unfinishTask(workerId, taskId);
-        assertSame(TaskState.IN_PROGRESS, manager.getTask(taskId).getTaskState());
-    }
-
-    @Test
-    @DisplayName("Assert that the Scanner is actually started when AM calls start")
-    public void assertScannerExists() {
-        try {
-            Scanner scanner = manager.getUserCommands().getScanner();
-        } catch (Exception e) {
-            fail("Scanner does not exists or can't be gotten by getScanner()");
-        }
-    }
-    @Test
-    @DisplayName("Check that every required surface command actually works")
-    public void assertCommandsAreRecognized() {
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("?"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("help"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("createWorker"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("createTask"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("selectTask"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("listWorkers"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("exit"));
-    }
-    @Test
-    @DisplayName("Check that every task command works")
-    public void assertFinishingTasksIsPossibleThroughUi() {
-        int workerId = manager.createWorker("Alfred");
-        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        manager.getUserCommands().handleInput("selectTask");
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput(taskId + ""));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("finish"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("unfinish"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("remove"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("back"));
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("edit"));
-    }
-    @Test
-    @DisplayName("Check that editing is possible through UI")
-    public void assertEditingTasksIsPossibleThroughUi() {
-        int workerId = manager.createWorker("Alfred");
-        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        manager.getUserCommands().handleInput("selectTask");
-        manager.getUserCommands().handleInput(taskId + "");
-        manager.getUserCommands().handleInput("edit");
-        manager.getUserCommands().handleInput("Walk;Walk 3 Miles");
-        assertEquals("Walk", manager.getTask(taskId).getName());
-        assertEquals("Walk 3 Miles", manager.getTask(taskId).getDescription());
-        manager.getUserCommands().handleInput("back");
-    }
-    @Test
-    @DisplayName("Assert that removing Workers is possible through the UI")
-    public void assertRemovingWorkersIsPossibleThroughUI() {
-        int workerId = manager.createWorker("Alfred");
-        int workerId2 = manager.createWorker("Balfred");
-        manager.getUserCommands().handleInput("listWorkers");
-        manager.getUserCommands().handleInput(workerId + "");
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("remove"));
-        manager.getUserCommands().handleInput(workerId2 + "");
-        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("back"));
-    }
-    @Test
-    @DisplayName("Assert that removing a worker removes the worker from the worker list")
-    public void assertRemoveWorkerActuallyRemoves() {
-        int workerId = manager.createWorker("Alfred");
-        manager.removeWorker(workerId);
-        assertThrows(IllegalArgumentException.class, () -> manager.getWorker(workerId)); // Use getWorker
-    }
 }