diff --git a/generated/labs/backend.java.grundlagen.console/.itninja.index.json b/generated/labs/backend.java.grundlagen.console/.itninja.index.json new file mode 100644 index 0000000..458a6c0 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/.itninja.index.json @@ -0,0 +1,45 @@ +{ + "generatedAt" : "2026-03-22T21:56:45.789807222Z", + "project" : "backend.java.grundlagen.console", + "files" : [ { + "path" : "README.md", + "size" : 2201, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1365, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 422, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/AsciiHouse.java", + "size" : 233, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/AsciiSwissFlag.java", + "size" : 245, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/HelloWorld.java", + "size" : 314, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/AsciiHouseTest.java", + "size" : 1754, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/AsciiSwissFlagTest.java", + "size" : 2499, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/HelloWorldTest.java", + "size" : 926, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.console/README.md b/generated/labs/backend.java.grundlagen.console/README.md new file mode 100644 index 0000000..071819e --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/README.md @@ -0,0 +1,92 @@ + + +# Java Exercises - Ausgabe auf die Kommandozeile + +Mit diesen Übungen kannst du dein Wissen über die Ausgabe auf die Kommandozeile (Konsole) vertiefen. + +## Voraussetzung + +- Du weisst, was mit Konsole gemeint ist. +- Du kannst Ausgaben auf die Konsole machen. +- Du weisst wie und warum man Zeichen escapen muss. + + + +## Aufgabe 1 - Hello World + +Passe den Code an damit `Hello World` auf der Konsole ausgegeben wird. + +```java + public static void printHelloWorld(){ + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/HelloWorld.java) + + + +## Aufgabe 2 - Ascii House + +Zeichne ein Haus in der Konsole. Du darfst dazu folgende Zeichen verwenden: + +- `'/'`, `'\'`, `'+'`, `'-'`, `'_'`, `'['`, `']'`, `'|'`, Leerzeichen (`' '`) + +```java + public static void printHouse(){ + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/AsciiHouse.java) + +> **Hinweis:** Vorsicht bei `'\'`, das ist ein besonderes Zeichen in einem String und muss escaped werden, das +> heisst für ein `'\'` muss man innerhalb von einem String das Zeichen zweimal schreiben → `".\\."` + +Falls unklar ist, was hier gemeint ist, schau dir [ASCII-Art](https://de.wikipedia.org/wiki/ASCII-Art) an. + +Hier eine Katze als Beispiel: + +```console + /\_/\ +( o.o ) + > ^ < +``` + +## Aufgabe 3 - Ascii Swiss Flag + +Zeichne eine Schweizer Fahne. Die Fahne muss einen Rahmen haben. Du darfst dazu +folgende Zeichen verwenden: + +- Im Rahmen: `'|'`, `'-'`, `'+''`, Leerzeichen (`' '`) +- Innerhalb: `'|'`, `'-'`, `'+'`, `'*'`, `'='`, `'@''`, Leerzeichen (`' '`) + +```java + public static void printSwissFlag(){ + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/AsciiSwissFlag.java) + +Falls unklar ist, was hier gemeint ist, schau dir [ASCII-Art](https://de.wikipedia.org/wiki/ASCII-Art) an. + +Hier ist die japanische Flagge als Beispiel: + +```console + ------------------ +| | +| @@@@ | +| @@@@@@@@ | +| @@@@@@@@@@ | +| @@@@@@@@ | +| @@@@ | +| | + ------------------ +``` diff --git a/generated/labs/backend.java.grundlagen.console/pom.xml b/generated/labs/backend.java.grundlagen.console/pom.xml new file mode 100644 index 0000000..6343b74 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + <>17 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..5a24353 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,16 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.AsciiHouse; +import ch.itninja.labs.basicexercises.AsciiSwissFlag; +import ch.itninja.labs.basicexercises.HelloWorld; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + HelloWorld.printHelloWorld(); + AsciiHouse.printHouse(); + AsciiSwissFlag.printSwissFlag(); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiHouse.java b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiHouse.java new file mode 100644 index 0000000..86adf4b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiHouse.java @@ -0,0 +1,14 @@ +package ch.itninja.labs.basicexercises; + +public class AsciiHouse { + + private AsciiHouse() { + // Prevent instantiation + } + + public static void printHouse(){ + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiSwissFlag.java b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiSwissFlag.java new file mode 100644 index 0000000..ada0a5c --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/AsciiSwissFlag.java @@ -0,0 +1,14 @@ +package ch.itninja.labs.basicexercises; + +public class AsciiSwissFlag { + + private AsciiSwissFlag() { + // Prevent instantiation + } + + public static void printSwissFlag(){ + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/HelloWorld.java b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/HelloWorld.java new file mode 100644 index 0000000..dcfde5d --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/main/java/ch/itninja/labs/basicexercises/HelloWorld.java @@ -0,0 +1,20 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for basic Hello World output. + */ +public class HelloWorld { + + private HelloWorld() { + // Prevent instantiation + } + + public static void printHelloWorld(){ + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} + + + diff --git a/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiHouseTest.java b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiHouseTest.java new file mode 100644 index 0000000..34ee223 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiHouseTest.java @@ -0,0 +1,54 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.List; +import java.util.Set; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +class AsciiHouseTest { + + @Test + void givenPrintHouse_whenCalled_thenOutputHasOnlyAllowedCharacters() { + // GIVEN + Set allowedChars = Set.of( + ' ', '/', '\\', '+', '-', '_', '[', ']', '|', '\n', '\r' + ); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + AsciiHouse.printHouse(); + } finally { + // System.out zurücksetzen, egal ob Fehler auftritt oder nicht + System.setOut(originalOut); + } + + // THEN + List lines = outputStream.toString().lines().toList(); + + System.out.println(lines); + + assertFalse(lines.isEmpty(), "Output should not be empty"); + assertTrue(lines.size() >= 2, "A house should have at least 2 lines, but has " + lines.size()); + + for (String line : lines) { + for (int pos = 0; pos < line.length(); pos++) { + char c = line.charAt(pos); + if (!allowedChars.contains(c)) { + fail("Invalid character '" + c + "' in line: " + line); + } + } + } + + ItNinjaOutput.PrintItNinjaOutput("AsciiHouse", "", String.join("\r\n", lines)); + } +} diff --git a/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiSwissFlagTest.java b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiSwissFlagTest.java new file mode 100644 index 0000000..75a3d96 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/AsciiSwissFlagTest.java @@ -0,0 +1,70 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.List; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class AsciiSwissFlagTest { + + @Test + void givenPrintSwissFlag_whenCalled_thenOutputHasValidFrameAndCharacters() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + AsciiSwissFlag.printSwissFlag(); + } finally { + System.setOut(originalOut); + } + + // THEN + List lines = outputStream.toString().lines().toList(); + + assertFalse(lines.isEmpty(), "Output should not be empty"); + assertTrue(lines.size() >= 3, "Flag should have at least 3 lines"); + + String allowedInnerChars = " +*"; + String allowedFrameChars = "|-_=`~"; + + int firstLineNumber = 0; + int lastLineNumber = lines.size() - 1; + for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) { + String line = lines.get(lineNumber); + + boolean isFirstLine = lineNumber == firstLineNumber; + boolean isLastLine = lineNumber == lastLineNumber; + if (isFirstLine || isLastLine) { + // Top or bottom line must contain a horizontal frame character + assertTrue( + line.chars().anyMatch(ch -> "-_=`~".indexOf(ch) >= 0), + "Top/bottom line must contain at least one horizontal border character" + ); + } else { + // Middle lines must start and end with '|' + assertTrue( + line.length() >= 2 && line.startsWith("|") && line.endsWith("|"), + "Line " + (lineNumber + 1) + " must start and end with '|'" + ); + } + + // All characters must be allowed + for (char c : line.toCharArray()) { + if (!allowedInnerChars.contains(String.valueOf(c)) && + !allowedFrameChars.contains(String.valueOf(c))) { + fail("Invalid character '" + c + "' in line: " + line); + } + } + } + + ItNinjaOutput.PrintItNinjaOutput("AsciiSwissFlag", "", String.join("\r\n", lines)); + + } +} diff --git a/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/HelloWorldTest.java b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/HelloWorldTest.java new file mode 100644 index 0000000..7aeedb1 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/basicexercises/HelloWorldTest.java @@ -0,0 +1,33 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class HelloWorldTest { + + @Test + void givenPrintHelloWorld_whenCalled_thenOutputIsHelloWorld() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + HelloWorld.printHelloWorld(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals("Hello World", output, "Output should be exactly 'Hello World'"); + + ItNinjaOutput.PrintItNinjaOutput("HelloWorld", "", output); + } +} diff --git a/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.console/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/.itninja.index.json b/generated/labs/backend.java.grundlagen.control-structures-if/.itninja.index.json new file mode 100644 index 0000000..a5c6607 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/.itninja.index.json @@ -0,0 +1,37 @@ +{ + "generatedAt" : "2026-03-22T21:57:29.904269411Z", + "project" : "backend.java.grundlagen.control-structures-if", + "files" : [ { + "path" : "README.md", + "size" : 4039, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 339, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/CompareNumbers.java", + "size" : 339, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/LeapYear.java", + "size" : 359, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/CompareNumbersTest.java", + "size" : 1449, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/LeapYearTest.java", + "size" : 2167, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/README.md b/generated/labs/backend.java.grundlagen.control-structures-if/README.md new file mode 100644 index 0000000..460a08b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/README.md @@ -0,0 +1,239 @@ + + +# Java Exercises - Variablen und bedingte Anweisungen + +Mit diesen Übungen kannst du dein Wissen über bedingte Ausführung vertiefen. + +#### Voraussetzung + +- Du verstehst und kennst die verschiedenen Conditional Statements. +- Du weisst, wann und wie welches Conditional Statement eingesetzt werden sollte. + + + +## Aufgabe 1 - Zahlenvergleich + +Passe die folgende Methode an. Vergleiche die beiden Zahlen 'zahl1' und 'zahl2' und gib das Resultat des Vergleichs auf +auf der Konsole aus: + +- `Zahl1(value1) ist kleiner als Zahl2(value2)` +- `Zahl1(value1) ist grösser als Zahl2(value2)` +- `Zahl1(value1) ist gleich gross wie Zahl2(value2)` + +Wobei in der Ausgabe `value1` und `value2` durch die tatsächlichen Werte ersetzt werden sollen. + +```java + public static void compareNumbers(int number1, int number2) { + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/CompareNumbers.java) + +**Beispiel 1:** + +Eingabe: + +```console +CompareNumbers.compareNumbers(-1, 5); +``` + +Ausgabe: + +```console +Zahl1(-1) ist kleiner als Zahl2(5) +``` + +**Beispiel 2:** + +Eingabe: + +```console +CompareNumbers.compareNumbers(23, 7); +``` + +Ausgabe: + +```console +Zahl1(23) ist grösser als Zahl2(7) +``` + +**Beispiel 3:** + +Eingabe: + +```console +CompareNumbers.compareNumbers(47, 47); +``` + +Ausgabe: + +```console +Zahl1(47) ist gleich gross wie Zahl2(47) +``` + +**Beispiel 4:** + +Eingabe: + +```console +CompareNumbers.compareNumbers(0, 0); +``` + +Ausgabe: + +```console +Zahl1(0) ist gleich gross wie Zahl2(0) +``` + +## Aufgabe 2 - Schaltjahr + +Passe die folgende Methode an. Stell fest, ob das übergebene Jahr ein Schaltjahr ist (gemäss gregorianischer Kalender). +Gib auf der Konsole das Resultat aus: + +- `Das Jahr year ist ein Schaltjahr gemäss gregorianischem Kalender` +- `Das Jahr year ist kein Schaltjahr gemäss gregorianischem Kalender` + +Wobei in der Ausgabe `year` durch das tatsächliche Jahr ersetzt werden soll. +Falls das Jahr ein Schaltjahr gemäss gregorianischem Kalender ist, soll die Methode `true` zurückgeben, andernfalls +`false`. + +> Verwende keine logischen Ausdrücke zur Berechnung des Schaltjahres. Nutze stattdessen if-else- und else-if Anweisungen. + +```java + public static boolean isLeapYear(int year) { + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/LeapYear.java) + +**Beispiel 1:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(1200); +``` + +Ausgabe: + +```console +Das Jahr 1200 ist kein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 2:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(1996); +``` + +Ausgabe: + +```console +Das Jahr 1996 ist ein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 3:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(1900); +``` + +Ausgabe: + +```console +Das Jahr 1900 ist kein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 4:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2000); +``` + +Ausgabe: + +```console +Das Jahr 2000 ist ein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 5:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2021); +``` + +Ausgabe: + +```console +Das Jahr 2021 ist kein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 6:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2024); +``` + +Ausgabe: + +```console +Das Jahr 2024 ist ein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 7:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2100); +``` + +Ausgabe: + +```console +Das Jahr 2100 ist kein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 8:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2400); +``` + +Ausgabe: + +```console +Das Jahr 2400 ist ein Schaltjahr gemäss gregorianischem Kalender +``` + +**Beispiel 9:** + +Eingabe: + +```console +boolean result = LeapYear.isLeapYear(2023); +``` + +Ausgabe: + +```console +Das Jahr 2023 ist kein Schaltjahr gemäss gregorianischem Kalender +``` diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/pom.xml b/generated/labs/backend.java.grundlagen.control-structures-if/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..6ed9140 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,15 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.CompareNumbers; +import ch.itninja.labs.basicexercises.LeapYear; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + CompareNumbers.compareNumbers(4, 7); + LeapYear.isLeapYear(1973); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/CompareNumbers.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/CompareNumbers.java new file mode 100644 index 0000000..d80f82a --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/CompareNumbers.java @@ -0,0 +1,20 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for comparing numbers. + */ +public class CompareNumbers { + + private CompareNumbers() { + // Prevent instantiation + } + + public static void compareNumbers(int number1, int number2) { + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} + + + diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/LeapYear.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/LeapYear.java new file mode 100644 index 0000000..5cb3155 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/main/java/ch/itninja/labs/basicexercises/LeapYear.java @@ -0,0 +1,19 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for leap year calculation. + */ +public class LeapYear { + + // IT-Ninja: Füge hier Deinen Code ein... + + private LeapYear() { + // Prevent instantiation + } + + public static boolean isLeapYear(int year) { + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/CompareNumbersTest.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/CompareNumbersTest.java new file mode 100644 index 0000000..9551037 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/CompareNumbersTest.java @@ -0,0 +1,40 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class CompareNumbersTest { + + @ParameterizedTest + @CsvSource({ + "1, -1, 5, 'Zahl1(-1) ist kleiner als Zahl2(5)'", + "2, 23, 7, 'Zahl1(23) ist grösser als Zahl2(7)'", + "3, 47, 47, 'Zahl1(47) ist gleich gross wie Zahl2(47)'", + "4, 0, 0, 'Zahl1(0) ist gleich gross wie Zahl2(0)'", + }) + void givenNumbers_whenCalled_thenOutputAsExpected(int lab, int value1, int value2, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + CompareNumbers.compareNumbers(value1, value2); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "For "+value1+" and "+value2+" output should be '"+ expectedResult +"'"); + + ItNinjaOutput.PrintItNinjaOutput("CompareNumbers"+lab, "CompareNumbers.compareNumbers("+value1+", "+value2+");", output); + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/LeapYearTest.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/LeapYearTest.java new file mode 100644 index 0000000..f77affe --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/basicexercises/LeapYearTest.java @@ -0,0 +1,46 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class LeapYearTest { + @ParameterizedTest + @CsvSource({ + "1, 1200, false, 'Das Jahr 1200 ist kein Schaltjahr gemäss gregorianischem Kalender'", + "2, 1996, true, 'Das Jahr 1996 ist ein Schaltjahr gemäss gregorianischem Kalender'", + "3, 1900, false, 'Das Jahr 1900 ist kein Schaltjahr gemäss gregorianischem Kalender'", + "4, 2000, true, 'Das Jahr 2000 ist ein Schaltjahr gemäss gregorianischem Kalender'", + "5, 2021, false, 'Das Jahr 2021 ist kein Schaltjahr gemäss gregorianischem Kalender'", + "6, 2024, true, 'Das Jahr 2024 ist ein Schaltjahr gemäss gregorianischem Kalender'", + "7, 2100, false, 'Das Jahr 2100 ist kein Schaltjahr gemäss gregorianischem Kalender'", + "8, 2400, true, 'Das Jahr 2400 ist ein Schaltjahr gemäss gregorianischem Kalender'", + "9, 2023, false, 'Das Jahr 2023 ist kein Schaltjahr gemäss gregorianischem Kalender'" + }) + void givenYears_whenCalled_thenOutputAsExpected(int lab, int year, boolean expectedResult, String expectedOutput) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + boolean result; + + try { + // WHEN + result = LeapYear.isLeapYear(year); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedOutput, output, "For "+year+" output should be '"+ expectedOutput +"'"); + assertEquals(expectedResult, result, "For "+year+" result should be '"+ result +"'"); + ItNinjaOutput.PrintItNinjaOutput("LeapYear"+lab, "boolean result = LeapYear.isLeapYear("+year+");", output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-if/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/.itninja.index.json b/generated/labs/backend.java.grundlagen.control-structures-loops/.itninja.index.json new file mode 100644 index 0000000..f2b7964 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/.itninja.index.json @@ -0,0 +1,29 @@ +{ + "generatedAt" : "2026-03-22T21:56:55.597104753Z", + "project" : "backend.java.grundlagen.control-structures-loops", + "files" : [ { + "path" : "README.md", + "size" : 4354, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 364, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java", + "size" : 605, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java", + "size" : 4380, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/README.md b/generated/labs/backend.java.grundlagen.control-structures-loops/README.md new file mode 100644 index 0000000..8932aeb --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/README.md @@ -0,0 +1,221 @@ + + +# Java Exercises - Loops + +Mit diesen Übungen kannst du dein Wissen über die Befehle `for`, `while` und `do` vertiefen. + +#### Voraussetzung + +- Du kennst die Befehle `for`, `while` und `do`. + + + +## Aufgabe 1 - Summe aller durch 8 teilbaren Zahlen von 1 bis 100 + +Passe die folgende Methode an. Zähle alle Zahlen von **1 bis 100** zusammen, welche durch **8** teilbar sind und gib das +Resultat auf der Konsole aus: + +- `Die Summe aller durch 8 teilbaren Zahlen von 1 bis 100 beträgt 624.` + +```java + public static void sumDivisibleByEightFixedRange() { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java) + +**Beispiel:** + +Eingabe: + +```console +NumberHelper.sumDivisibleByEightFixedRange() +``` + +Ausgabe: + +```console +Die Summe aller durch 8 teilbaren Zahlen von 1 bis 100 beträgt 624. +``` + +## Aufgabe 2 - Summe aller durch X teilbaren Zahlen + +Passe die folgende Methode an. Zähle alle Zahlen von `min` bis `max` zusammen, welche durch `divisor` teilbar sind und gib das +Resultat auf der Konsole aus: + +- `Die Summe aller durch [divisor] teilbaren Zahlen von [min] bis [max] beträgt [result].` + +> Abgrenzung: Wenn `max` kleiner als `min` ist oder wenn `divisor` kleiner gleich 0 ist, soll folgender Text auf der +> Konsole ausgegeben werden: `Berechnung mit diesen Werten nicht möglich` + + +```java + public static void sumDivisibleBy(int min, int max, int divisor) { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java) + +**Beispiel 1:** + +Eingabe: + +```console +NumberHelper.sumDivisibleBy(10, 30, 7); +``` + +Ausgabe: + +```console +Die Summe aller durch 7 teilbaren Zahlen von 10 bis 30 beträgt 63. +``` + +**Beispiel 2:** + +Eingabe: + +```console +NumberHelper.sumDivisibleBy(30, 10, 7); +``` + +Ausgabe: + +```console +Berechnung mit diesen Werten nicht möglich. +``` + +## Aufgabe 3 - Summe gemeinsames Vielfaches zweier Zahlen + +Passe die folgende Methode an. Zähle alle Zahlen von `min` bis `max` zusammen, welche ein gemeinsames Vielfaches von den +beiden Zahlen `number1` und `number2`sind und gib das Resultat auf der Konsole aus: + +- `Summe der Zahlen von [min] bis [max], die ein gemeinsames Vielfache von [number1] und [number2] sind: [result].` + +> Abgrenzung: Wenn `max` kleiner als `min` ist oder wenn eine der Zahlen `number1` oder 'number2' kleiner gleich 0 ist, +> soll folgender Text auf der Konsole ausgegeben werden: `Berechnung mit diesen Werten nicht möglich` + + +```java + public static void sumCommonMultiples(int min, int max, int number1, int number2) { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java) + +**Beispiel 1:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(1, 50, 3, 5); +``` + +Ausgabe: + +```console +Summe der Zahlen von 1 bis 50, die ein gemeinsames Vielfache von 3 und 5 sind: 90. +``` + +**Beispiel 2:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(1, 100, 4, 6); +``` + +Ausgabe: + +```console +Summe der Zahlen von 1 bis 100, die ein gemeinsames Vielfache von 4 und 6 sind: 432. +``` + +**Beispiel 3:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(1, 10, 4, 6); +``` + +Ausgabe: + +```console +Summe der Zahlen von 1 bis 10, die ein gemeinsames Vielfache von 4 und 6 sind: 0. +``` + +**Beispiel 4:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(50, 1, 3, 5); +``` + +Ausgabe: + +```console +Berechnung mit diesen Werten nicht möglich. +``` + +**Beispiel 5:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(15, 15, 3, 5); +``` + +Ausgabe: + +```console +Summe der Zahlen von 15 bis 15, die ein gemeinsames Vielfache von 3 und 5 sind: 15. +``` + +**Beispiel 6:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(60, 60, 4, 6); +``` + +Ausgabe: + +```console +Summe der Zahlen von 60 bis 60, die ein gemeinsames Vielfache von 4 und 6 sind: 60. +``` + +**Beispiel 7:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(-30, 30, 6, 10); +``` + +Ausgabe: + +```console +Summe der Zahlen von -30 bis 30, die ein gemeinsames Vielfache von 6 und 10 sind: 0. +``` + +**Beispiel 8:** + +Eingabe: + +```console +NumberHelper.sumCommonMultiples(1, 1000, 8, 12); +``` + +Ausgabe: + +```console +Summe der Zahlen von 1 bis 1000, die ein gemeinsames Vielfache von 8 und 12 sind: 20664. +``` diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/pom.xml b/generated/labs/backend.java.grundlagen.control-structures-loops/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..ca6c7bd --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,15 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.NumberHelper; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + NumberHelper.sumDivisibleByEightFixedRange(); + NumberHelper.sumDivisibleBy(2, 64, 4); + NumberHelper.sumCommonMultiples(1, 88, 3, 5); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java b/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java new file mode 100644 index 0000000..69b1b5f --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java @@ -0,0 +1,26 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for month operations. +*/ +public class NumberHelper { + + private NumberHelper() { + // Prevent instantiation + } + + public static void sumDivisibleByEightFixedRange() { + + // IT-Ninja: Füge hier Deinen Code ein... + } + + public static void sumDivisibleBy(int min, int max, int divisor) { + + // IT-Ninja: Füge hier Deinen Code ein... + } + + public static void sumCommonMultiples(int min, int max, int number1, int number2) { + + // IT-Ninja: Füge hier Deinen Code ein... + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java b/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java new file mode 100644 index 0000000..9dcd3fe --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java @@ -0,0 +1,122 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class NumberHelperTest { + + @Test + void givenSumDivisibleByEightFixedRange_whenCalled_thenOutputAsExpected() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + NumberHelper.sumDivisibleByEightFixedRange(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + String expected = "Die Summe aller durch 8 teilbaren Zahlen von 1 bis 100 beträgt 624."; + assertEquals(expected, output, "Output is not as expected"); + + ItNinjaOutput.PrintItNinjaOutput("SumDivisibleByEightFixedRange", "NumberHelper.sumDivisibleByEightFixedRange()", output); + } + + @ParameterizedTest + @CsvSource({ + "1, 10, 30, 7, 63", + "2, 30, 10, 7, -1", + }) + void givenSumDivisibleBy_whenCalled_thenOutputAsExpected(int lab, int min, int max, int divisor, int result) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + NumberHelper.sumDivisibleBy(min, max, divisor); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + String expectedResult = result > 0 ? String.format("Die Summe aller durch %d teilbaren Zahlen von %d bis %d beträgt %d." + , divisor, min, max, result) : "Berechnung mit diesen Werten nicht möglich."; + + assertEquals(expectedResult, output, "Output is not as expected."); + + // For documentation + String input = String.format("NumberHelper.sumDivisibleBy(%d, %d, %d);" + , min, max, divisor); + + ItNinjaOutput.PrintItNinjaOutput("SumDivisibleBy"+lab, input, output); + } + + @ParameterizedTest + @CsvSource({ + // einfache Beispiele mit kleinem Bereich + "1, 1, 50, 3, 5, 90", + "2, 1, 100, 4, 6, 432", + "0, 10, 30, 2, 3, 84", + "0, 1, 60, 5, 10, 210", + + // keine gemeinsamen Vielfachen im Bereich + "3, 1, 10, 4, 6, 0", + "0, 20, 24, 3, 5, 0", + + // min > max → Berechnung nicht möglich + "4, 50, 1, 3, 5, -1", + + // Randwert = genau ein gemeinsames Vielfaches + "5, 15, 15, 3, 5, 15", + "6, 60, 60, 4, 6, 60", + + // negatives Intervall (z. B. für erweiterte Version) + "7, -30, 30, 6, 10, 0", // negatives Vielfaches ignoriert (nach Bedarf anpassen) + + // sehr großer Bereich + "8, 1, 1000, 8, 12, 20664" + }) + + void givenSumCommonMultiples_whenCalled_thenOutputAsExpected(int lab, int min, int max, int number1, int number2, int result) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + NumberHelper.sumCommonMultiples(min, max, number1, number2); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + String expectedResult = result >= 0 ? String.format("Summe der Zahlen von %d bis %d, die ein gemeinsames Vielfache von %d und %d sind: %d." + , min, max, number1, number2, result) : "Berechnung mit diesen Werten nicht möglich."; + + assertEquals(expectedResult, output, "Output is not as expected."); + + // For documentation + String input = String.format("NumberHelper.sumCommonMultiples(%d, %d, %d, %d);" + , min, max, number1, number2); + + ItNinjaOutput.PrintItNinjaOutput("SumCommonMultiples"+lab, input, output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-loops/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/.itninja.index.json b/generated/labs/backend.java.grundlagen.control-structures-switch/.itninja.index.json new file mode 100644 index 0000000..622e5b4 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/.itninja.index.json @@ -0,0 +1,37 @@ +{ + "generatedAt" : "2026-03-22T21:56:50.669661600Z", + "project" : "backend.java.grundlagen.control-structures-switch", + "files" : [ { + "path" : "README.md", + "size" : 2767, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 379, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/MonthHelper.java", + "size" : 325, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/WeekHelper.java", + "size" : 331, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/MonthHelperTest.java", + "size" : 1317, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/WeekHelperTest.java", + "size" : 1751, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/README.md b/generated/labs/backend.java.grundlagen.control-structures-switch/README.md new file mode 100644 index 0000000..242b9a8 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/README.md @@ -0,0 +1,188 @@ + + +# Java Exercises - Das Switch Statement + +Mit diesen Übungen kannst du dein Wissen über den Befehl `switch` vertiefen. + +#### Voraussetzung + +- Du kennst den `switch` Befehl. + + + +## Aufgabe 1 - Monat ausgeben + +Passe die folgende Methode an. Gib abhängig von der Variable `month` den passenden Monat auf der Konsole aus. Der Wert +`1` soll dabei dem Monat `Januar` entsprechen, `2` dem Monat `Februar`, usw. Für Zahlen welche keinem Monat entsprechen +soll `ungültiger Monat` auf der Konsole ausgegeben werden. + +```java + public static void printMonthByNumber(int month) { + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/MonthHelper.java) + +**Beispiel 1:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(1); +``` + +Ausgabe: + +```console +Januar +``` + +**Beispiel 2:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(5); +``` + +Ausgabe: + +```console +Mai +``` + +**Beispiel 3:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(9); +``` + +Ausgabe: + +```console +September +``` + +**Beispiel 4:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(12); +``` + +Ausgabe: + +```console +Dezember +``` + +**Beispiel 5:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(22); +``` + +Ausgabe: + +```console +ungültiger Monat +``` + +**Beispiel 6:** + +Eingabe: + +```console +MonthHelper.printMonthByNumber(-3); +``` + +Ausgabe: + +```console +ungültiger Monat +``` + +## Aufgabe 2 - Wochentag + +Passe die folgende Methode an. Gib abhängig von der Variable `weekdayName` auf der Konsole aus, um welchen Wochentag es sich +handelt: + +- `Der [weekdayName] ist der [weekday]. Tag in der Woche.` +- `[weekdayName] entspricht keinem bekannten Wochentag.` + +Wobei in der Ausgabe `[weekdayName]` durch den Namen des Wochentags ersetzt werden soll und `[weekday]` durch den Tag +der Woche, welche dem Wochentag entspricht. Der Montag soll dabei der erste Tag in der Woche sein. + +```java + public static void printWeekdayNumber(String weekdayName) { + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/WeekHelper.java) + +**Beispiel 1:** + +Eingabe: + +```console +WeekHelper.printWeekdayNumber("Freitag"); +``` + +Ausgabe: + +```console +Der Freitag ist der 5. Tag in der Woche. +``` + +**Beispiel 2:** + +Eingabe: + +```console +WeekHelper.printWeekdayNumber("Donnerstag"); +``` + +Ausgabe: + +```console +Der Donnerstag ist der 4. Tag in der Woche. +``` + +**Beispiel 3:** + +Eingabe: + +```console +WeekHelper.printWeekdayNumber("Weihnachten"); +``` + +Ausgabe: + +```console +Weihnachten entspricht keinem bekannten Wochentag. +``` + +**Beispiel 4:** + +Eingabe: + +```console +WeekHelper.printWeekdayNumber("Samstag"); +``` + +Ausgabe: + +```console +Der Samstag ist der 6. Tag in der Woche. +``` diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/pom.xml b/generated/labs/backend.java.grundlagen.control-structures-switch/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..0430f33 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,17 @@ +package ch.itninja.labs; + +import java.time.Month; + +import ch.itninja.labs.basicexercises.MonthHelper; +import ch.itninja.labs.basicexercises.WeekHelper; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + WeekHelper.printWeekdayNumber("Donnerstag"); + MonthHelper.printMonthByNumber(3); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/MonthHelper.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/MonthHelper.java new file mode 100644 index 0000000..5be76b0 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/MonthHelper.java @@ -0,0 +1,17 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for month operations. +*/ +public class MonthHelper { + + private MonthHelper() { + // Prevent instantiation + } + + public static void printMonthByNumber(int month) { + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/WeekHelper.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/WeekHelper.java new file mode 100644 index 0000000..0e9727f --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/main/java/ch/itninja/labs/basicexercises/WeekHelper.java @@ -0,0 +1,17 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for week operations. + */ +public class WeekHelper { + + private WeekHelper() { + // Prevent instantiation + } + + public static void printWeekdayNumber(String weekdayName) { + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/MonthHelperTest.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/MonthHelperTest.java new file mode 100644 index 0000000..eb97714 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/MonthHelperTest.java @@ -0,0 +1,42 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class MonthHelperTest { + + @ParameterizedTest + @CsvSource({ + "1, 1, 'Januar'", + "2, 5, 'Mai'", + "3, 9, 'September'", + "4, 12, 'Dezember'", + "5, 22, 'ungültiger Monat'", + "6, -3, 'ungültiger Monat'", + }) + void givenNumbers_whenCalled_thenOutputAsExpected(int lab, int month, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + MonthHelper.printMonthByNumber(month); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "Output is not as expected."); + + ItNinjaOutput.PrintItNinjaOutput("MonthByNumber"+lab, "MonthHelper.printMonthByNumber("+month+");", output); + } +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/WeekHelperTest.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/WeekHelperTest.java new file mode 100644 index 0000000..df07e73 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/basicexercises/WeekHelperTest.java @@ -0,0 +1,44 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class WeekHelperTest { + @ParameterizedTest + @CsvSource({ + "1, 'Montag', 'Der Montag ist der 1. Tag in der Woche.'", + "0, 'Dienstag', 'Der Dienstag ist der 2. Tag in der Woche.'", + "0, 'Mittwoch', 'Der Mittwoch ist der 3. Tag in der Woche.'", + "2, 'Donnerstag', 'Der Donnerstag ist der 4. Tag in der Woche.'", + "1, 'Freitag', 'Der Freitag ist der 5. Tag in der Woche.'", + "4, 'Samstag', 'Der Samstag ist der 6. Tag in der Woche.'", + "0, 'Sonntag', 'Der Sonntag ist der 7. Tag in der Woche.'", + "3, 'Weihnachten', 'Weihnachten entspricht keinem bekannten Wochentag.'" + }) + void givenYears_whenCalled_thenOutputAsExpected(int lab, String weekdayName, String expectedOutput) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + boolean result; + + try { + // WHEN + WeekHelper.printWeekdayNumber(weekdayName); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedOutput, output, "Output is not as expected."); + ItNinjaOutput.PrintItNinjaOutput("Weekday"+lab, "WeekHelper.printWeekdayNumber(\""+weekdayName+"\");", output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.control-structures-switch/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.debugging/.itninja.index.json b/generated/labs/backend.java.grundlagen.debugging/.itninja.index.json new file mode 100644 index 0000000..c55c572 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/.itninja.index.json @@ -0,0 +1,33 @@ +{ + "generatedAt" : "2026-03-22T21:57:14.386068352Z", + "project" : "backend.java.grundlagen.debugging", + "files" : [ { + "path" : "README.md", + "size" : 2492, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 578, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java", + "size" : 977, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/util/MagicNumberHelper.java", + "size" : 5510, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/MagicNumberTest.java", + "size" : 792, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.debugging/README.md b/generated/labs/backend.java.grundlagen.debugging/README.md new file mode 100644 index 0000000..f4903c4 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/README.md @@ -0,0 +1,87 @@ + + +# Java Exercises - Debugging + +Mit diesen Übungen kannst du dein Wissen zum Thema Debuggen vertiefen. + +#### Voraussetzung + +- Du weisst was ein Breakpoint ist. +- Du kannst den Debugger starten und den Code Schritt für Schritt ausführen + + + +{{< ninja warning>}} +Zum Lösen der folgenden Aufgaben darfst du den Quellcode nicht verändern! +{{< /ninja >}} + +## Aufgabe 1 - Wert in Zwischenberechnung herausfinden + +Finde heraus, welcher Wert z hat, wenn x = 500 ist. + +```java + public static int generate(int iterations) throws InterruptedException { + + // IT-Ninja: Zum Lösen der folgenden Aufgaben darfst du den Quellcode nicht verändern! + + // IT-Ninja: Aufgabe 1 - Finde heraus, welcher Wert z hat, wenn x = 500 ist. + + // IT-Ninja: Aufgabe 2 - Hat z am Ende immer den gleichen Wert, auch wenn du in der 'for'-Schleife einen + // Breakpoint gesetzt hast? + + // IT-Ninja: Erstelle Screenshots und diskutiere deine Resultate und Erkenntnisse mit deinem Praxisbildner. + + int z = 0; + for(int x = 0; x < iterations; x++) { + z = MagicNumberHelper.getSecretValue(x); + } + return z; + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java) + +## Aufgabe 2 - Verhalten des Programms beim Debuggen + +Beantworte folgende Frage: Hat z am Ende immer den gleichen Wert, auch wenn du in der 'for'-Schleife einen Breakpoint +gesetzt hast? + +```java + public static int generate(int iterations) throws InterruptedException { + + // IT-Ninja: Zum Lösen der folgenden Aufgaben darfst du den Quellcode nicht verändern! + + // IT-Ninja: Aufgabe 1 - Finde heraus, welcher Wert z hat, wenn x = 500 ist. + + // IT-Ninja: Aufgabe 2 - Hat z am Ende immer den gleichen Wert, auch wenn du in der 'for'-Schleife einen + // Breakpoint gesetzt hast? + + // IT-Ninja: Erstelle Screenshots und diskutiere deine Resultate und Erkenntnisse mit deinem Praxisbildner. + + int z = 0; + for(int x = 0; x < iterations; x++) { + z = MagicNumberHelper.getSecretValue(x); + } + return z; + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java) + +**Beispiel:** + +Eingabe: + +```console +MagicNumber.generate(1000); +``` + +Ausgabe: + +```console +-32414486 +``` + +{{< ninja info>}} +Erstelle ScreenShots und diskutiere deine Resultate und Erkenntnisse mit deinem Praxisbildner. +{{< /ninja >}} diff --git a/generated/labs/backend.java.grundlagen.debugging/pom.xml b/generated/labs/backend.java.grundlagen.debugging/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..9b455ce --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,20 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.MagicNumber; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + try { + int iterations = 1000; + System.out.println("Starting calculation..."); + int z = MagicNumber.generate(iterations); + System.out.println("The z-Value after " + iterations + " iterations is " + z); + } catch (Exception exception){ + System.out.println("Exception occurred: " + exception); + } + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java new file mode 100644 index 0000000..e595669 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/MagicNumber.java @@ -0,0 +1,31 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.basicexercises.util.MagicNumberHelper; + +/** + * Utility class providing helper methods for debug operations. + */ +public class MagicNumber { + + private MagicNumber() { + // Prevent instantiation + } + + public static int generate(int iterations) throws InterruptedException { + + // IT-Ninja: Zum Lösen der folgenden Aufgaben darfst du den Quellcode nicht verändern! + + // IT-Ninja: Aufgabe 1 - Finde heraus, welcher Wert z hat, wenn x = 500 ist. + + // IT-Ninja: Aufgabe 2 - Hat z am Ende immer den gleichen Wert, auch wenn du in der 'for'-Schleife einen + // Breakpoint gesetzt hast? + + // IT-Ninja: Erstelle Screenshots und diskutiere deine Resultate und Erkenntnisse mit deinem Praxisbildner. + + int z = 0; + for(int x = 0; x < iterations; x++) { + z = MagicNumberHelper.getSecretValue(x); + } + return z; + } +} diff --git a/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/util/MagicNumberHelper.java b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/util/MagicNumberHelper.java new file mode 100644 index 0000000..7716340 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/src/main/java/ch/itninja/labs/basicexercises/util/MagicNumberHelper.java @@ -0,0 +1,168 @@ +package ch.itninja.labs.basicexercises.util; + +/** + * DebugHelper provides a deterministic but non-trivial mapping from integers to integers, + * useful for debugging exercises that require conditional breakpoints. + * + * Features: + * - Two consecutive calls with the same input in the same epoch produce different values + * (output depends on internal state/history). + * - If more than thresholdMs (default: 20 ms) pass between calls, a new epoch starts: + * the internal state is re-initialized deterministically from (seed, epochId), + * and the same first N calls in each epoch repeat the same values. + * + * Usage (default instance): + * int v1 = DebugHelper.getSecretValue(10); + * int v2 = DebugHelper.getSecretValue(10); // different from v1 (same epoch) + * Thread.sleep(200); + * int v3 = DebugHelper.getSecretValue(10); // same as v1 (new epoch) + */ +public final class MagicNumberHelper { + + private MagicNumberHelper() { /* no instances */ } + + // Default mapper: deterministic with fixed seed and 20 ms threshold + private static final EpochHistoryMapper DEFAULT_MAPPER = + new EpochHistoryMapper(12345, 20); + + /** + * Returns a secret value for the given input using the default mapper. + */ + public static int getSecretValue(int input) { + return DEFAULT_MAPPER.getSecretValue(input); + } + + /** + * Returns the current epoch id of the default mapper. + */ + public static int getCurrentEpochId() { + return DEFAULT_MAPPER.getEpochId(); + } + + /** + * Resets the default mapper to epoch 0 and initial state. + */ + public static void resetDefault() { + DEFAULT_MAPPER.reset(); + } + + // ===================================================================== + // Inner class: stateful, epoch-based, history-dependent number mapper + // ===================================================================== + + /** + * Stateful mapper whose output depends on: + * - seed + * - current epoch + * - previous output (internal state) + * - input + * - position within epoch + * + * Same sequence of calls within an epoch produces the same sequence of outputs. + * Waiting more than thresholdMs between calls starts a new epoch with the same + * initial state, so the sequence repeats. + */ + public static final class EpochHistoryMapper { + + private final int seed; + private final long thresholdMs; + + private int epochId = 0; + private long lastCallNanos = 0L; + + // Per-epoch evolving state + private int state; + private int position = 0; + + public EpochHistoryMapper(int seed) { + this(seed, 20); + } + + public EpochHistoryMapper(int seed, long thresholdMs) { + this.seed = seed; + this.thresholdMs = thresholdMs; + startNewEpoch(); + } + + /** + * Returns a value that depends on (seed, epochId, previous state, input, position). + * Two consecutive calls with the same input within the same epoch yield different outputs. + * After a gap > thresholdMs, a new epoch starts and the first calls repeat deterministically. + */ + public synchronized int getSecretValue(int input) { + long now = System.nanoTime(); + if (lastCallNanos != 0L && nanosToMillis(now - lastCallNanos) > thresholdMs) { + startNewEpoch(); + } + lastCallNanos = now; + + // Output depends on evolving state and current input + int out = strongMix(state, input, epochId, position); + + // Evolve state for next call + state = evolve(state, out, input, epochId, position); + + position++; + return out; + } + + /** + * Returns the current epoch id. + */ + public synchronized int getEpochId() { + return epochId; + } + + /** + * Resets everything to epoch 0 with initial state. + */ + public synchronized void reset() { + epochId = 0; + lastCallNanos = 0L; + startNewEpoch(); + } + + // ------- internals ------- + + private void startNewEpoch() { + state = initialState(seed, epochId); + position = 0; + epochId++; + } + + private static int initialState(int seed, int epochId) { + int x = seed ^ (epochId * 0x9E3779B9); + x ^= Integer.rotateLeft(x, 13); + x *= 0x7FEB352D; + x ^= (x >>> 15); + x *= 0x846CA68B; + x ^= (x >>> 16); + return x; + } + + private static int strongMix(int prevState, int input, int epoch, int pos) { + int x = prevState; + x ^= Integer.rotateLeft(input * 0x9E3779B9, (pos & 31)); + x ^= (epoch * 0x7F4A7C15); + x ^= (x >>> 16); + x *= 0x7FEB352D; + x ^= (x >>> 15); + x *= 0x846CA68B; + x ^= (x >>> 16); + return x; + } + + private static int evolve(int prevState, int out, int input, int epoch, int pos) { + int y = out ^ Integer.rotateLeft(prevState, (pos % 29) + 1); + y ^= (input * 0x85EBCA6B); + y ^= Integer.rotateLeft(epoch, (pos % 5) + 3); + y *= 0xC2B2AE35; + y ^= (y >>> 13); + return y; + } + + private static long nanosToMillis(long nanos) { + return nanos / 1_000_000L; + } + } +} diff --git a/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/basicexercises/MagicNumberTest.java b/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/basicexercises/MagicNumberTest.java new file mode 100644 index 0000000..ca64669 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/basicexercises/MagicNumberTest.java @@ -0,0 +1,27 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class MagicNumberTest { + @Test + void givenNumber_whenCalled_thenResultAsExpected() { + // GIVEN + int iterations = 1000; + int expected = -32414486; + + int result = 0; + try { + // WHEN + result = MagicNumber.generate(iterations); + } catch (Exception exception){ + System.out.println("Exception occured: " + exception); + } + + // THEN + assertEquals(expected, result, "Result is not as expected."); + ItNinjaOutput.PrintItNinjaOutput("Debug", "MagicNumber.generate("+iterations+");", "" + result); + } +} diff --git a/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.debugging/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/.itninja.index.json b/generated/labs/backend.java.grundlagen.exception-handling/.itninja.index.json new file mode 100644 index 0000000..0139dbf --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/.itninja.index.json @@ -0,0 +1,37 @@ +{ + "generatedAt" : "2026-03-22T21:57:25.001258407Z", + "project" : "backend.java.grundlagen.exception-handling", + "files" : [ { + "path" : "README.md", + "size" : 6744, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1385, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 792, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/AgeValidator.java", + "size" : 310, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/Calculator.java", + "size" : 1472, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/AgeValidatorTest.java", + "size" : 1611, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/CalculatorTest.java", + "size" : 3139, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 370, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.exception-handling/README.md b/generated/labs/backend.java.grundlagen.exception-handling/README.md new file mode 100644 index 0000000..ff4ab62 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/README.md @@ -0,0 +1,238 @@ + + +# Java Exercises - Exception Handling + +Mit diesen Übungen kannst du erste Erfahrungen beim behandeln von Exceptions sammeln. + +## Voraussetzungen + +- Du kennst `try`, `catch`, `throw`, `throws` und `finally`. + + + +## Aufgabe 1 – Sichere Division + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Liefert das Resultat der Divsion von `a` durch `b`. Bei einer Divsion durch 0 wird der Wert +`Integer.MAX_VALUE` zurückgeben. +**Parameter1:** a [int] +**Parameter2:** b [int] +**Rückgabewert:** Resultat der Berechnung [int], `Integer,MAX_VALUE` bei Division durch 0. +**Bedingungen:** Verwende `try` / `catch`, um Division durch 0 korrekt abzufangen. `if` darf nicht verwendet werden. + +--- + +> Halte die Coding Guidelines ein! + +```java +public class Calculator { + + private Calculator() { + // Prevent instantiation + } + + // Place here the methode for "Sichere Division". + + // IT-Ninja: Füge hier Deinen Code ein: + + // Place here the methode for "Mindestwert sicherstellen". + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/Calculator.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Sichere Division" + // IT-Ninja: Füge hier Deinen Code ein: + + try { + int age = 16; + // Sample call for "Alter prüfen" + // IT-Ninja: Füge hier Deinen Code ein: + System.out.printf("Das Alter %d ist gültig.%n", age); + } catch (IllegalArgumentException e) { + System.out.println("Fehler: " + e.getMessage()); + } + + // Sample call for "Mindestwert sicherstellen" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode für "Sichere Division", welche wir testen wollen (etwas wie: res = methode(a, b);): + // IT-Ninja: Füge hier Deinen Code ein: + } finally { + } +``` + +::src(src/test/java/ch/itninja/labs/CalculatorTest.java) + + + +## Aufgabe 2 – Alter prüfen + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- + +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Prüft das Alter und wirft eine `IllegalArgumentException`, wenn das Alter kleiner 0 oder grösser 130 ist. +Für gültige Werte passiert nichts. +**Parameter1:** age [int] +**Rückgabewert:** keiner, `IllegalArgumentException` wenn Alter ausserhalb des erlaubten Bereichs ist. + +--- + +> Halte die Coding Guidelines ein! + +```java +public class AgeValidator { + + // IT-Ninja: Füge hier Deinen Code ein: + + private AgeValidator() { + // Prevent instantiation + } + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/AgeValidator.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Sichere Division" + // IT-Ninja: Füge hier Deinen Code ein: + + try { + int age = 16; + // Sample call for "Alter prüfen" + // IT-Ninja: Füge hier Deinen Code ein: + System.out.printf("Das Alter %d ist gültig.%n", age); + } catch (IllegalArgumentException e) { + System.out.println("Fehler: " + e.getMessage()); + } + + // Sample call for "Mindestwert sicherstellen" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode für "Sichere Division", welche wir testen wollen (etwas wie: res = methode(a, b);): + // IT-Ninja: Füge hier Deinen Code ein: + } catch (IllegalArgumentException e) { + excptionOccured = true; + exceptionMessage = e.getMessage(); + } +``` + +::src(src/test/java/ch/itninja/labs/AgeValidatorTest.java) + + + +## Aufgabe 3 – Mindestwert sicherstellen + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- + +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Dividiert `a` durch `b` und danach `c` durch `d`. Das Resultat wird jeweils zum Total hinzugefügt. Fehler +werden mit **einem einzigen** `try` / `catch` abgefangen. Im `finally`-Block wird abschliessend sichergestellt, dass das +Total mindestens 100 beträgt. +**Parameter1:** a [int] +**Parameter2:** b [int] +**Parameter3:** c [int] +**Parameter4:** b [int] +**Rückgabewert:** Total der Berechnung [int] + +--- +Bei dieser Aufgabe ist es wichtig, dass du die Funktion genau umsetzt auch wenn sie eigentlich keinen Sinn macht oder +besser implementiert werden könnte. + +> Halte die Coding Guidelines trotzdem ein! + +```java +public class Calculator { + + private Calculator() { + // Prevent instantiation + } + + // Place here the methode for "Sichere Division". + + // IT-Ninja: Füge hier Deinen Code ein: + + // Place here the methode for "Mindestwert sicherstellen". + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/Calculator.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Sichere Division" + // IT-Ninja: Füge hier Deinen Code ein: + + try { + int age = 16; + // Sample call for "Alter prüfen" + // IT-Ninja: Füge hier Deinen Code ein: + System.out.printf("Das Alter %d ist gültig.%n", age); + } catch (IllegalArgumentException e) { + System.out.println("Fehler: " + e.getMessage()); + } + + // Sample call for "Mindestwert sicherstellen" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode für "Mindestwert sicherstellen", welche wir testen wollen (etwas wie: min = methode(a, b, c);): + // IT-Ninja: Füge hier Deinen Code ein: + } finally { + } +``` + +::src(src/test/java/ch/itninja/labs/CalculatorTest.java) + + diff --git a/generated/labs/backend.java.grundlagen.exception-handling/pom.xml b/generated/labs/backend.java.grundlagen.exception-handling/pom.xml new file mode 100644 index 0000000..41b8c00 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-02-03-08-methods + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..3fd2c44 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,27 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.Calculator; +import ch.itninja.labs.basicexercises.AgeValidator; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + // Sample call for "Sichere Division" + // IT-Ninja: Füge hier Deinen Code ein... + + try { + int age = 16; + // Sample call for "Alter prüfen" + // IT-Ninja: Füge hier Deinen Code ein... + System.out.printf("Das Alter %d ist gültig.%n", age); + } catch (IllegalArgumentException e) { + System.out.println("Fehler: " + e.getMessage()); + } + + // Sample call for "Mindestwert sicherstellen" + // IT-Ninja: Füge hier Deinen Code ein... + } +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/AgeValidator.java b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/AgeValidator.java new file mode 100644 index 0000000..e589de0 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/AgeValidator.java @@ -0,0 +1,15 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for age validation operations. + */ +public class AgeValidator { + + // IT-Ninja: Füge hier Deinen Code ein... + + private AgeValidator() { + // Prevent instantiation + } + + // IT-Ninja: Füge hier Deinen Code ein... +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/Calculator.java b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/Calculator.java new file mode 100644 index 0000000..e54da59 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/main/java/ch/itninja/labs/basicexercises/Calculator.java @@ -0,0 +1,38 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for some calculations. + */ +public class Calculator { + + private Calculator() { + // Prevent instantiation + } + + // Place here the methode for "Sichere Division". + /** + * Name der Methode: Bestimme selber einen passenden Namen für die Methode + * Funktion: Liefert das Resultat der Divsion von a durch b. Bei einer Divsion durch 0 wird der Wert + * Integer.MAX_VALUE zurückgeben. + * Parameter1: a [int] + * Parameter2: b [int] + * Rückgabewert: Resultat der Berechnung [int], Integer,MAX_VALUE bei Division durch 0. + * Bedingungen: Verwende try / catch, um Division durch 0 korrekt abzufangen. if darf nicht verwendet werden. + */ + // IT-Ninja: Füge hier Deinen Code ein... + + // Place here the methode for "Mindestwert sicherstellen". + /** + * + * Name der Methode: Bestimme selber einen passenden Namen für die Methode + * Funktion: Dividiert a durch b und danach c durch d. Das Resultat wird jeweils zum Total hinzugefügt. Fehler + * werden mit einem einzigen try / catch abgefangen. Im finally-Block wird abschliessend sichergestellt, dass das + * Total mindestens 100 beträgt. + * Parameter1: a [int] + * Parameter2: b [int] + * Parameter3: c [int] + * Parameter4: b [int] + * Rückgabewert: Total der Berechnung [int] + */ + // IT-Ninja: Füge hier Deinen Code ein... +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/AgeValidatorTest.java b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/AgeValidatorTest.java new file mode 100644 index 0000000..d496bf1 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/AgeValidatorTest.java @@ -0,0 +1,47 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.AgeValidator; +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; + +public class AgeValidatorTest { + + @ParameterizedTest + @CsvSource({ + "1, 120, false", + "2, 21, false", + "3, 0, false", + "4, 130, false", + "5, -12, true", + "6, 145, true", + }) + void givenValidateAge_whenCalled_thenResultAsExpected(int lab, int age, boolean exceptionExpected) { + + // Init to a number not used by the methode. + boolean excptionOccured = false; + String exceptionMessage = null; + + try { + // WHEN + // Aufruf der Methode für "Sichere Division", welche wir testen wollen (etwas wie: res = methode(a, b);): + // IT-Ninja: Füge hier Deinen Code ein... + } catch (IllegalArgumentException e) { + excptionOccured = true; + exceptionMessage = e.getMessage(); + } + + // THEN + assertEquals(exceptionExpected, excptionOccured, "Program flow was not throwing as expected."); + + // For documentation + String input = String.format("yourImplementation(%d);", age); + String output = "Beispiel Ausgabe: " + (excptionOccured? + String.format("Fehler: %s%n", exceptionMessage): + String.format("Das Alter %d ist gültig.%n", age)); + + ItNinjaOutput.PrintItNinjaOutput("AgeValidator"+lab, input, output); + } +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/CalculatorTest.java b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/CalculatorTest.java new file mode 100644 index 0000000..92618ff --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/CalculatorTest.java @@ -0,0 +1,81 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.Calculator; + +import static org.junit.jupiter.api.Assertions.*; +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +public class CalculatorTest { + + private static final int METHOD_NOT_IMPLEMENTED = -2; + + @ParameterizedTest + @CsvSource({ + "1, 120, 2, 60", + "2, 21, 3, 7", + "3, 4, 8, 0", + "4, 48, 0, 2147483647", + }) + void givenDivide_whenCalled_thenResultAsExpected(int lab, int a, int b, int expected) { + + // Init to a number not used by the methode. + int res = METHOD_NOT_IMPLEMENTED; + + try { + // WHEN + // Aufruf der Methode für "Sichere Division", welche wir testen wollen (etwas wie: res = methode(a, b);): + // IT-Ninja: Füge hier Deinen Code ein... + } finally { + } + + // Pre-Check for implementation + assertNotEquals(METHOD_NOT_IMPLEMENTED , res + , "Please ensure that the method is called in try code block and the result is stored in variable 'res'!"); + + // THEN + assertEquals(expected, res, "The number seems not to be the minimum of three."); + + // For documentation + String input = String.format("total = yourImplementation(%d, %d);", a, b); + String output = String.format("Beispiel Ausgabe: Die Division von '%d / %d' ergibt %d.%n", a, b, res); + + ItNinjaOutput.PrintItNinjaOutput("SafeDivision"+lab, input, output); + } + + @ParameterizedTest + @CsvSource({ + "1, 120, 2, 230, 2, 175, ''", + "2, 21, 3, 32, 2, 100, 'Total zu klein -> 100'", + "3, 240, 2, 48, 0, 120, 'Exception bei `c / d`, aber `a / b` > 100'", + "4, 48, 0, 240, 2, 100, 'Exception bei `a / b`, Total darum 0 und zu klein -> 100'", + }) + void givenCalculation_whenCalled_thenResultAsExpected(int lab, int a, int b, int c, int d, int expected, String comment) { + + // Init to a number not used by the methode. + int total = METHOD_NOT_IMPLEMENTED; + + try { + // WHEN + // Aufruf der Methode für "Mindestwert sicherstellen", welche wir testen wollen (etwas wie: min = methode(a, b, c);): + // IT-Ninja: Füge hier Deinen Code ein... + } finally { + } + + // Pre-Check for implementation + assertNotEquals(METHOD_NOT_IMPLEMENTED , total + , "Please ensure that the method is called in try code block and the result is stored in variable 'total'!"); + + // THEN + assertEquals(expected, total, "The number seems not to be the minimum of three."); + + // For documentation + String input = String.format("total = yourImplementation(%d, %d, %d, %d);", a, b, c, d); + String output = String.format("Beispiel Ausgabe: Das Total für die Berechnung mit '%d, %d, %d, %d' ist %d%s.%n" + , a, b, c, d, total, comment.isEmpty() ? "" : " // " + comment); + + ItNinjaOutput.PrintItNinjaOutput("Calculation"+lab, input, output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..b64244b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.exception-handling/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,10 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, Object output) { + System.out.printf("\n", lab); + System.out.printf("Eingabe: %s\n", input); + System.out.printf("Ausgabe: %s\n", output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.hello-world/.gitignore b/generated/labs/backend.java.grundlagen.hello-world/.gitignore new file mode 100644 index 0000000..0d2599c --- /dev/null +++ b/generated/labs/backend.java.grundlagen.hello-world/.gitignore @@ -0,0 +1,5 @@ +*.iml +.idea/ +out/ +target/ +build/ \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.hello-world/.itninja.index.json b/generated/labs/backend.java.grundlagen.hello-world/.itninja.index.json new file mode 100644 index 0000000..3009ec7 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.hello-world/.itninja.index.json @@ -0,0 +1,17 @@ +{ + "generatedAt" : "2026-03-22T21:57:15.092279995Z", + "project" : "backend.java.grundlagen.hello-world", + "files" : [ { + "path" : ".gitignore", + "size" : 32, + "language" : "gitignore" + }, { + "path" : "README.md", + "size" : 740, + "language" : "markdown" + }, { + "path" : "src/Main.java", + "size" : 119, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.hello-world/README.md b/generated/labs/backend.java.grundlagen.hello-world/README.md new file mode 100644 index 0000000..0a3f33b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.hello-world/README.md @@ -0,0 +1,30 @@ +# Java Exercises - Einfaches Hello World + +Hier kannst Du erste Erfahrungen sammeln mit einem einfachen Java Programm + +## Voraussetzung + +- Du bist bereit die nachfolgende Anleitung gründlich zu lesen. + + + +## Einführung + +Der zur Übung gehörende Quellcode zeigt dir ein einfaches Programm, welches den Text `Hello World` auf die Konsole +ausgibt. Er soll dir helfen, dich mit der Entwicklungsumgebung (IntelliJ) vertraut zu machen. + +## Aufgabe - Hello World + +Schau Dir das Programm an und versuche es zum Laufen zu bringen. Versuche, ein paar kleine Änderungen am Programm +vorzunehmen. + +```java +public class Main { + public static void main(String[] args) { + + System.out.println("Hello, world!"); + } +} +``` + +::src(src/Main.java) diff --git a/generated/labs/backend.java.grundlagen.hello-world/src/Main.java b/generated/labs/backend.java.grundlagen.hello-world/src/Main.java new file mode 100644 index 0000000..645dcf8 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.hello-world/src/Main.java @@ -0,0 +1,6 @@ +public class Main { + public static void main(String[] args) { + + System.out.println("Hello, world!"); + } +} diff --git a/generated/labs/backend.java.grundlagen.logic/.itninja.index.json b/generated/labs/backend.java.grundlagen.logic/.itninja.index.json new file mode 100644 index 0000000..bb622f1 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/.itninja.index.json @@ -0,0 +1,45 @@ +{ + "generatedAt" : "2026-03-22T21:56:39.197515656Z", + "project" : "backend.java.grundlagen.logic", + "files" : [ { + "path" : "README.md", + "size" : 8679, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 658, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/AgeCalculator.java", + "size" : 554, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/Basket.java", + "size" : 1666, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/CalculateForms.java", + "size" : 746, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/AgeCalculatorTest.java", + "size" : 2546, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/BasketTest.java", + "size" : 1832, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/CalculateFormsTest.java", + "size" : 5133, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.logic/README.md b/generated/labs/backend.java.grundlagen.logic/README.md new file mode 100644 index 0000000..b41ac55 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/README.md @@ -0,0 +1,419 @@ + + +# Java Exercises - Einfache Berechnungen + +Mit diesen Übungen kannst du dein Wissen über einfache Berechnungen vertiefen. + +#### Voraussetzung + +- Du weisst, wie man in Java mit Zahlen rechnet. + + + +## Aufgabe 1 - geometrische Berechnungen + +Passe die folgenden Methoden an. Berechne Flächen, Umfang und Volumen und gib das Resultat auf der Konsole aus: + +- `Das Rechteck mit a=[value1]cm und b=[value2]cm hat eine Fläche von [result]cm2.` +- `Das Dreieck mit g=[value1]cm und h=[value2]cm hat eine Fläche von [result]cm2.` +- `Der Kreis mit dem Radius [value]cm hat eine Fläche von [result]cm2.` +- `Das Rechteck mit a=[value1]cm und b=[value2]cm hat einen Umfang von [result]cm.` + +Wobei in der Ausgabe die Platzhalter mit den eckigen Klammern durch die entsprechenden Zahlen ersetzt werden sollen. +Ganzzahlen sollen ohne '.' und Nachkommastellen angezeigt werden, Dezimalzahlen mit 2 Stellen hinter dem Punkt. + +```java + public static void printRectArea(int sideA, int sideB) { + + // IT-Ninja: Füge hier Deinen Code ein: + } + + public static void printTriangleArea(int sideC, int heightC) { + + // IT-Ninja: Füge hier Deinen Code ein: + } + + public static void printCircleArea(int radius) { + + // IT-Ninja: Füge hier Deinen Code ein: + } + + public static void printRectPerimeter(int sideA, int sideB) { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/CalculateForms.java) + +### Rechteck Flächenberechnung + +**Beispiel 1:** + +Eingabe: + +```console +CalculateForms.printRectArea(4, 5); +``` + +Ausgabe: + +```console +Das Rechteck mit a=4cm und b=5cm hat eine Fläche von 20cm2. +``` + +**Beispiel 2:** + +Eingabe: + +```console +CalculateForms.printRectArea(3, 7); +``` + +Ausgabe: + +```console +Das Rechteck mit a=3cm und b=7cm hat eine Fläche von 21cm2. +``` + +**Beispiel 3:** + +Eingabe: + +```console +CalculateForms.printRectArea(6, 4); +``` + +Ausgabe: + +```console +Das Rechteck mit a=6cm und b=4cm hat eine Fläche von 24cm2. +``` + +**Beispiel 4:** + +Eingabe: + +```console +CalculateForms.printRectArea(0, 0); +``` + +Ausgabe: + +```console +Das Rechteck mit a=0cm und b=0cm hat eine Fläche von 0cm2. +``` + +### Dreieck Flächenberechnung + +**Beispiel 1:** + +Eingabe: + +```console +CalculateForms.printTriangleArea(4, 5); +``` + +Ausgabe: + +```console +Das Dreieck mit c=4cm und h=5cm hat eine Fläche von 10cm2. +``` + +**Beispiel 2:** + +Eingabe: + +```console +CalculateForms.printTriangleArea(3, 12); +``` + +Ausgabe: + +```console +Das Dreieck mit c=3cm und h=12cm hat eine Fläche von 18cm2. +``` + +**Beispiel 3:** + +Eingabe: + +```console +CalculateForms.printTriangleArea(6, 4); +``` + +Ausgabe: + +```console +Das Dreieck mit c=6cm und h=4cm hat eine Fläche von 12cm2. +``` + +**Beispiel 4:** + +Eingabe: + +```console +CalculateForms.printTriangleArea(0, 0); +``` + +Ausgabe: + +```console +Das Dreieck mit c=0cm und h=0cm hat eine Fläche von 0cm2. +``` + +### Kreis Flächenberechnung + +**Beispiel 1:** + +Eingabe: + +```console +CalculateForms.printCircleArea(4); +``` + +Ausgabe: + +```console +Der Kreis mit r=4cm hat eine Fläche von 50.27cm2. +``` + +**Beispiel 2:** + +Eingabe: + +```console +CalculateForms.printCircleArea(3); +``` + +Ausgabe: + +```console +Der Kreis mit r=3cm hat eine Fläche von 28.27cm2. +``` + +**Beispiel 3:** + +Eingabe: + +```console +CalculateForms.printCircleArea(6); +``` + +Ausgabe: + +```console +Der Kreis mit r=6cm hat eine Fläche von 113.10cm2. +``` + +**Beispiel 4:** + +Eingabe: + +```console +CalculateForms.printCircleArea(0); +``` + +Ausgabe: + +```console +Der Kreis mit r=0cm hat eine Fläche von 0.00cm2. +``` + +### Rechteck Umfangberechnung + +**Beispiel 1:** + +Eingabe: + +```console +CalculateForms.printRectPerimeter(4, 5); +``` + +Ausgabe: + +```console +Das Rechteck mit a=4cm und b=5cm hat einen Umfang von 18cm. +``` + +**Beispiel 2:** + +Eingabe: + +```console +CalculateForms.printRectPerimeter(3, 12); +``` + +Ausgabe: + +```console +Das Rechteck mit a=3cm und b=12cm hat einen Umfang von 30cm. +``` + +**Beispiel 3:** + +Eingabe: + +```console +CalculateForms.printRectPerimeter(6, 4); +``` + +Ausgabe: + +```console +Das Rechteck mit a=6cm und b=4cm hat einen Umfang von 20cm. +``` + +**Beispiel 4:** + +Eingabe: + +```console +CalculateForms.printRectPerimeter(0, 0); +``` + +Ausgabe: + +```console +Das Rechteck mit a=0cm und b=0cm hat einen Umfang von 0cm. +``` + +## Aufgabe 2 - Checkout + +Passe die folgenden Methoden an. Nutze in einer Methode nur `double`, in der anderen `BigDecimal`. Erstelle für die untenstehende Einkaufsliste für jeden Artikel eine Variable und weise +der Variable den entsprechenden Wert zu: + +- Apfel: CHF 0.10 +- Brot: CHF 1.10 +- Milch: CHF 2.20 +- Ei: CHF 0.20 +- Butter: CHF 2.10 + +Erstelle ebenfalls eine Variable `totalExpected` mit dem zu erwartenden Total und berechne es (im Kopf oder Taschenrechner). + +Zähle die Preise der Produkte mittels Java-Code zusammen und speichere sie in der Variable `total`. Der darauf folgende +Code wird dann die beiden Werte vergleichen und eine entsprechende Ausgabe machen (was der Code macht wirst du im +nächsten Modul kennenlernen). + +> Denke beim Erstellen der Variablen daran, dass bei it-ninja der Code immer in englisch sein sollte, nur die Ausgabe +> auf den Bildschirm soll auf deutsch sein. + + +```java + public static void printTotalBigDecimal(){ + + BigDecimal totalExpected = new BigDecimal("0.0"); // Expected total price (your calculation) + BigDecimal total = new BigDecimal(0); // Actual total price (computed) + // to add 2 BigDecimal you can use total = big1.add(big2).add(big3) + + // IT-Ninja: Füge hier Deinen Code ein: + String expectedResult; + if(total.compareTo(totalExpected) == 0){ + expectedResult = "wie erwartet"; + } + else if(total.compareTo(totalExpected) > 0){ + expectedResult = "zu hoch"; + } + else { + expectedResult = "zu tief"; + } + System.out.println("Alle Artikel zusammen kosten CHF " + total + ". Der Preis ist " + expectedResult + "."); + } + + public static void printTotalDouble(){ + + double totalExpected = 0; // Expected total price (your calculation) + double total = 0; // Actual total price (computed) + + // IT-Ninja: Füge hier Deinen Code ein: + String expectedResult; + if(total == totalExpected){ + expectedResult = "wie erwartet"; + } + else if(total > totalExpected){ + expectedResult = "zu hoch"; + } + else { + expectedResult = "zu tief"; + } + System.out.printf("Alle Artikel zusammen kosten CHF %.2f. Der Preis ist %s.%n", total, expectedResult); + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/Basket.java) + +Wenn du beide Methoden angepasst hat, vergleiche die Ausgabe. Du solltest folgende Ausgabe erhalten: + +**Beispielausgabe:** + +```console +Alle Artikel zusammen kosten CHF 5.70. Der Preis ist wie erwartet. +``` + + +## Aufgabe 3 - Alter in Monaten + +Passe die folgende Methode an. Berechne dein Alter in ganzen Monaten. Zähle den Monat wo du geboren wurdest und den +aktuellen als ganzen Monat dazu. Gib Dein Alter auf der Konsole aus: + +- `Ich bin am dd.mm.yyyy geboren und heute am dd.mm.yyyy z Monate alt.` + +Wobei in der Ausgabe `dd.mm.yyyy` durch das tatsächliche Datum von Deinem Geburtstag resp. dem heutigen Datum ersetzt +werden soll und `z` durch die Anzahl Monate. + +> Im Quellcode findest du auch statische Variablen (`dayOfBirth`, `monthOfBirth`, `yearOfBirth`, `dayOfToday`, +> `monthOfToday`, `yearOfToday`). Passe diese Variablen an und nutze sie in in deinem Code. Es wird erwartet, dass sich +> eine Änderung einer dieser Variablen auf die Berechnung aber auch auf die Ausgabe in der Konsole auswirkt. Was es +> genau mit `static` auf sich hat lernst du bald. + +```java + public static void ageInMonths() { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/AgeCalculator.java) + +**Beispiel 1:** + +Eingabe: + +```console +AgeCalculator.dayOfBirth = 1; +AgeCalculator.monthOfBirth = 9; +AgeCalculator.yearOfBirth = 1973; +AgeCalculator.dayOfToday = 22; +AgeCalculator.monthOfToday = 7; +AgeCalculator.yearOfToday = 2025; + +AgeCalculator.ageInMonths(); +``` + +Ausgabe: + +```console +Ich bin am 01.09.1973 geboren und heute am 22.07.2025 623 Monate alt. +``` + +**Beispiel 2:** + +Eingabe: + +```console +AgeCalculator.dayOfBirth = 15; +AgeCalculator.monthOfBirth = 4; +AgeCalculator.yearOfBirth = 2008; +AgeCalculator.dayOfToday = 8; +AgeCalculator.monthOfToday = 8; +AgeCalculator.yearOfToday = 2025; + +AgeCalculator.ageInMonths(); +``` + +Ausgabe: + +```console +Ich bin am 15.04.2008 geboren und heute am 08.08.2025 209 Monate alt. +``` diff --git a/generated/labs/backend.java.grundlagen.logic/pom.xml b/generated/labs/backend.java.grundlagen.logic/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..476bcd6 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,24 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.AgeCalculator; +import ch.itninja.labs.basicexercises.Basket; +import ch.itninja.labs.basicexercises.CalculateForms; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + // call methodes with some test parameters + CalculateForms.printRectArea(5, 4); + CalculateForms.printTriangleArea(8, 3); + CalculateForms.printCircleArea(4); + CalculateForms.printRectPerimeter(5, 4); + + Basket.printTotalBigDecimal(); + Basket.printTotalDouble(); + + AgeCalculator.ageInMonths(); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/AgeCalculator.java b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/AgeCalculator.java new file mode 100644 index 0000000..1d25192 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/AgeCalculator.java @@ -0,0 +1,24 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for leap year calculation. + */ +public class AgeCalculator { + + public static int dayOfBirth = 11; + public static int monthOfBirth = 5; + public static int yearOfBirth = 1973; + + public static int dayOfToday = 22; + public static int monthOfToday = 7; + public static int yearOfToday = 2025; + + private AgeCalculator() { + // Prevent instantiation + } + + public static void ageInMonths() { + + // IT-Ninja: Füge hier Deinen Code ein... + } +} diff --git a/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/Basket.java b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/Basket.java new file mode 100644 index 0000000..92bc3ce --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/Basket.java @@ -0,0 +1,54 @@ +package ch.itninja.labs.basicexercises; + +import java.math.BigDecimal; + +/** + * Utility class providing methods for basket calculation. + */ +public class Basket { + + private Basket() { + // Prevent instantiation + } + + public static void printTotalBigDecimal(){ + + BigDecimal totalExpected = new BigDecimal("0.0"); // Expected total price (your calculation) + BigDecimal total = new BigDecimal(0); // Actual total price (computed) + // to add 2 BigDecimal you can use total = big1.add(big2).add(big3) + + // IT-Ninja: Füge hier Deinen Code ein... + String expectedResult; + if(total.compareTo(totalExpected) == 0){ + expectedResult = "wie erwartet"; + } + else if(total.compareTo(totalExpected) > 0){ + expectedResult = "zu hoch"; + } + else { + expectedResult = "zu tief"; + } + System.out.println("Alle Artikel zusammen kosten CHF " + total + ". Der Preis ist " + expectedResult + "."); + } + + public static void printTotalDouble(){ + + double totalExpected = 0; // Expected total price (your calculation) + double total = 0; // Actual total price (computed) + + // IT-Ninja: Füge hier Deinen Code ein... + String expectedResult; + if(total == totalExpected){ + expectedResult = "wie erwartet"; + } + else if(total > totalExpected){ + expectedResult = "zu hoch"; + } + else { + expectedResult = "zu tief"; + } + System.out.printf("Alle Artikel zusammen kosten CHF %.2f. Der Preis ist %s.%n", total, expectedResult); + + } + +} diff --git a/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/CalculateForms.java b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/CalculateForms.java new file mode 100644 index 0000000..005f413 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/main/java/ch/itninja/labs/basicexercises/CalculateForms.java @@ -0,0 +1,37 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing methods for comparing numbers. + */ +public class CalculateForms { + + static final double PI = 3.141592653589793; + + private CalculateForms() { + // Prevent instantiation + } + + public static void printRectArea(int sideA, int sideB) { + + // IT-Ninja: Füge hier Deinen Code ein... + } + + public static void printTriangleArea(int sideC, int heightC) { + + // IT-Ninja: Füge hier Deinen Code ein... + } + + public static void printCircleArea(int radius) { + + // IT-Ninja: Füge hier Deinen Code ein... + } + + public static void printRectPerimeter(int sideA, int sideB) { + + // IT-Ninja: Füge hier Deinen Code ein... + } + +} + + + diff --git a/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/AgeCalculatorTest.java b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/AgeCalculatorTest.java new file mode 100644 index 0000000..5be300a --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/AgeCalculatorTest.java @@ -0,0 +1,71 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class AgeCalculatorTest { + + @ParameterizedTest + @CsvSource({ + "1, 1, 9, 1973, 22, 7, 2025, 623", + "2, 15, 4, 2008, 8, 8, 2025, 209", + }) + void givenNumbers_whenCalled_thenOutputAsExpected(int lab, int dayOfBirth, int monthOfBirth, int yearOfBirth, + int dayOfToday, int monthOfToday, int yearOfToday, + int monthsExpected) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + AgeCalculator.dayOfBirth = dayOfBirth; + AgeCalculator.monthOfBirth = monthOfBirth; + AgeCalculator.yearOfBirth = yearOfBirth; + AgeCalculator.dayOfToday = dayOfToday; + AgeCalculator.monthOfToday = monthOfToday; + AgeCalculator.yearOfToday = yearOfToday; + + String expectedResult = String.format("Ich bin am %02d.%02d.%04d geboren und heute am %02d.%02d.%04d %d Monate alt.", + dayOfBirth, monthOfBirth, yearOfBirth, + dayOfToday, monthOfToday, yearOfToday, + monthsExpected); + + try { + // WHEN + AgeCalculator.ageInMonths(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "Output is not as expected"); + + // For documentation + String input = String.format( + "AgeCalculator.dayOfBirth = %d;\n" + + "AgeCalculator.monthOfBirth = %d;\n" + + "AgeCalculator.yearOfBirth = %d;\n" + + "AgeCalculator.dayOfToday = %d;\n" + + "AgeCalculator.monthOfToday = %d;\n" + + "AgeCalculator.yearOfToday = %d;\n" + + "\n" + + "AgeCalculator.ageInMonths();", + dayOfBirth, + monthOfBirth, + yearOfBirth, + dayOfToday, + monthOfToday, + yearOfToday + ); + ItNinjaOutput.PrintItNinjaOutput("AgeInMonths"+lab, input, output); + } + + +} diff --git a/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/BasketTest.java b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/BasketTest.java new file mode 100644 index 0000000..0d2afdf --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/BasketTest.java @@ -0,0 +1,58 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class BasketTest { + + @Test + void givenPrintTotalBigDecimal_whenCalled_thenOutputAsExpected() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + Basket.printTotalBigDecimal(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + final String expectedResult = "Alle Artikel zusammen kosten CHF 5.70. Der Preis ist wie erwartet."; + assertEquals(expectedResult, output, "Output not as expected"); + + ItNinjaOutput.PrintItNinjaOutput("Basket.BigDecimal", "", output); + } + + @Test + void givenPrintTotalDouble_whenCalled_thenOutputAsExpected() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + Basket.printTotalDouble(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + final String expectedResult = "Alle Artikel zusammen kosten CHF 5.70. Der Preis ist zu hoch."; + assertEquals(expectedResult, output, "Output not as expected"); + + ItNinjaOutput.PrintItNinjaOutput("Basket.Double", "", output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/CalculateFormsTest.java b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/CalculateFormsTest.java new file mode 100644 index 0000000..e735006 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/basicexercises/CalculateFormsTest.java @@ -0,0 +1,122 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class CalculateFormsTest { + + @ParameterizedTest + @CsvSource({ + "1, 4, 5, 'Das Rechteck mit a=4cm und b=5cm hat eine Fläche von 20cm2.'", + "2, 3, 7, 'Das Rechteck mit a=3cm und b=7cm hat eine Fläche von 21cm2.'", + "3, 6, 4, 'Das Rechteck mit a=6cm und b=4cm hat eine Fläche von 24cm2.'", + "4, 0, 0, 'Das Rechteck mit a=0cm und b=0cm hat eine Fläche von 0cm2.'", + }) + void givenNumbers_whenCalledPrintRectArea_thenOutputAsExpected(int lab, int value1, int value2, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + CalculateForms.printRectArea(value1, value2); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "For "+value1+" and "+value2+" output should be '"+ expectedResult +"'"); + + ItNinjaOutput.PrintItNinjaOutput("CalculateForms.RectArea"+lab, "CalculateForms.printRectArea("+value1+", "+value2+");", output); + } + + @ParameterizedTest + @CsvSource({ + "1, 4, 5, 'Das Dreieck mit c=4cm und h=5cm hat eine Fläche von 10cm2.'", + "2, 3, 12, 'Das Dreieck mit c=3cm und h=12cm hat eine Fläche von 18cm2.'", + "3, 6, 4, 'Das Dreieck mit c=6cm und h=4cm hat eine Fläche von 12cm2.'", + "4, 0, 0, 'Das Dreieck mit c=0cm und h=0cm hat eine Fläche von 0cm2.'", + }) + void givenNumbers_whenCalledPrintTriangleArea_thenOutputAsExpected(int lab, int value1, int value2, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + CalculateForms.printTriangleArea(value1, value2); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "For "+value1+" and "+value2+" output should be '"+ expectedResult +"'"); + + ItNinjaOutput.PrintItNinjaOutput("CalculateForms.TriangleArea"+lab, "CalculateForms.printTriangleArea("+value1+", "+value2+");", output); + } + + @ParameterizedTest + @CsvSource({ + "1, 4, 'Der Kreis mit r=4cm hat eine Fläche von 50.27cm2.'", + "2, 3, 'Der Kreis mit r=3cm hat eine Fläche von 28.27cm2.'", + "3, 6, 'Der Kreis mit r=6cm hat eine Fläche von 113.10cm2.'", + "4, 0, 'Der Kreis mit r=0cm hat eine Fläche von 0.00cm2.'", + }) + void givenNumbers_whenCalledPrintCircleArea_thenOutputAsExpected(int lab, int value1, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + CalculateForms.printCircleArea(value1); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "For "+value1+" output should be '"+ expectedResult +"'"); + + ItNinjaOutput.PrintItNinjaOutput("CalculateForms.CircleArea"+lab, "CalculateForms.printCircleArea("+value1+");", output); + } + + @ParameterizedTest + @CsvSource({ + "1, 4, 5, 'Das Rechteck mit a=4cm und b=5cm hat einen Umfang von 18cm.'", + "2, 3, 12, 'Das Rechteck mit a=3cm und b=12cm hat einen Umfang von 30cm.'", + "3, 6, 4, 'Das Rechteck mit a=6cm und b=4cm hat einen Umfang von 20cm.'", + "4, 0, 0, 'Das Rechteck mit a=0cm und b=0cm hat einen Umfang von 0cm.'", + }) + void givenNumbers_whenCalledPrintRectPerimeter_thenOutputAsExpected(int lab, int value1, int value2, String expectedResult) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + CalculateForms.printRectPerimeter(value1, value2); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertEquals(expectedResult, output, "For "+value1+" and "+value2+" output should be '"+ expectedResult +"'"); + + ItNinjaOutput.PrintItNinjaOutput("CalculateForms.RectPerimeter"+lab, "CalculateForms.printRectPerimeter("+value1+", "+value2+");", output); + } + +} diff --git a/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.logic/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.methods/.itninja.index.json b/generated/labs/backend.java.grundlagen.methods/.itninja.index.json new file mode 100644 index 0000000..10a11d2 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/.itninja.index.json @@ -0,0 +1,45 @@ +{ + "generatedAt" : "2026-03-22T21:57:20.200219913Z", + "project" : "backend.java.grundlagen.methods", + "files" : [ { + "path" : "README.md", + "size" : 6615, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1385, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 612, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/FibonacciHelper.java", + "size" : 198, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/MessageHelper.java", + "size" : 196, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java", + "size" : 195, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/FibonacciHelperTest.java", + "size" : 1544, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/MessageHelperTest.java", + "size" : 1804, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java", + "size" : 1537, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.methods/README.md b/generated/labs/backend.java.grundlagen.methods/README.md new file mode 100644 index 0000000..b9080bd --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/README.md @@ -0,0 +1,345 @@ + + +# Java Exercises - Methoden + +Mit diesen Übungen kannst du dein Wissen über Methoden vertiefen. + +#### Voraussetzung + + + + +## Aufgabe 1: Nachricht drucken + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- + +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Gibt eine Nachricht auf der Konsole aus, Format: `Nachricht an [Name des Empfängers]: [Nachricht]` +**Parameter1:** Name des Empfängers [String] +**Parameter2:** Nachricht [String] +**Rückgabewert:** Keiner + +--- + +> Halte die Coding Guidelines ein! + +```java +public class MessageHelper { + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/MessageHelper.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Nachricht drucken" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Minimum von drei Zahlen" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Fibonacci" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: methode(name, message);): + // IT-Ninja: Füge hier Deinen Code ein: + } finally { + System.setOut(originalOut); + } +``` + +::src(src/test/java/ch/itninja/labs/basicexercises/MessageHelperTest.java) + +**Beispiel 1:** + +Eingabe: + +```console +yourImplementation("Peter", "Das Meeting beginnt um 9 Uhr."); +``` + +Ausgabe: + +```console +Nachricht an Peter: Das Meeting beginnt um 9 Uhr. +``` + +**Beispiel 2:** + +Eingabe: + +```console +yourImplementation("Linda", "Bitte rufe Hans Mustermann zurück."); +``` + +Ausgabe: + +```console +Nachricht an Linda: Bitte rufe Hans Mustermann zurück. +``` + +## Aufgabe 2: Minimum von drei Zahlen + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- + +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Gibt die kleinste von 3 Zahlen zurück +**Parameter1:** Erste Zahl [int] +**Parameter2:** Zweite Zahl [int] +**Parameter3:** Dritte Zahl [int] +**Rückgabewert:** Kleinste der 3 Zahlen [int] + +--- + +> Halte die Coding Guidelines ein! + +```java +public class NumberHelper { + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Nachricht drucken" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Minimum von drei Zahlen" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Fibonacci" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: min = methode(a, b, c);): + // IT-Ninja: Füge hier Deinen Code ein: + } finally { + } +``` + +::src(src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java) + +**Beispiel 1:** + +Eingabe: + +```console +min = yourImplementation(63, 22, 98); +``` + +Ausgabe: + +```console +Example Output: The minimum from 63, 22 and 98 is 22. + +``` + +**Beispiel 2:** + +Eingabe: + +```console +min = yourImplementation(17, 67, 32); +``` + +Ausgabe: + +```console +Example Output: The minimum from 17, 67 and 32 is 17. + +``` + +**Beispiel 3:** + +Eingabe: + +```console +min = yourImplementation(4, 56, 3); +``` + +Ausgabe: + +```console +Example Output: The minimum from 4, 56 and 3 is 3. + +``` + +## Aufgabe 3: Fibonacci + +Passe untenstehenden Quellcode an und füge folgende Methode hinzu: + +--- + +**Name der Methode:** *Bestimme selber einen passenden Namen für die Methode* +**Funktion:** Berechnet die n-te Zahl der Fibonacci-Folge. +**Parameter1:** n [int] +**Rückgabewert:** n-te Zahl der Fibonacci-Folge [int] +**Abgrenzung:** Gibt -1 zurück, wenn Fibonacci-Folge ausserhalb des Wertebreichs von int ist. + +--- + +Informationen zur Fibonacci-Folge findest du [hier](https://de.wikipedia.org/wiki/Fibonacci-Folge). + +> Halte die Coding Guidelines ein! + +```java +public class FibonacciHelper { + + // IT-Ninja: Füge hier Deinen Code ein: +} +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/FibonacciHelper.java) + +Wenn du die Methode implementiert hast, kannst du sie aus `main` aufrufen. + +```java + public static void main(String[] args) { + + // Sample call for "Nachricht drucken" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Minimum von drei Zahlen" + // IT-Ninja: Füge hier Deinen Code ein: + + // Sample call for "Fibonacci" + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +Falls du sie testen willst, kannst du sie aus dem vorbereiteten Test aufrufen. + +```java + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: fibonacci = methode(n);): + // IT-Ninja: Füge hier Deinen Code ein: + } finally { + } +``` + +::src(src/test/java/ch/itninja/labs/basicexercises/FibonacciHelperTest.java) + +**Beispiel 1:** + +Eingabe: + +```console +fibonacci = yourImplementation(0); +``` + +Ausgabe: + +```console +Example Output: The 0. element of the Fibonacci sequence is 0. + +``` + +**Beispiel 2:** + +Eingabe: + +```console +fibonacci = yourImplementation(1); +``` + +Ausgabe: + +```console +Example Output: The 1. element of the Fibonacci sequence is 1. + +``` + +**Beispiel 3:** + +Eingabe: + +```console +fibonacci = yourImplementation(2); +``` + +Ausgabe: + +```console +Example Output: The 2. element of the Fibonacci sequence is 1. + +``` + +**Beispiel 4:** + +Eingabe: + +```console +fibonacci = yourImplementation(7); +``` + +Ausgabe: + +```console +Example Output: The 7. element of the Fibonacci sequence is 13. + +``` + +**Beispiel 5:** + +Eingabe: + +```console +fibonacci = yourImplementation(-5); +``` + +Ausgabe: + +```console +Example Output: The -5. element of the Fibonacci sequence is 0. + +``` + +**Beispiel 6:** + +Eingabe: + +```console +fibonacci = yourImplementation(100); +``` + +Ausgabe: + +```console +Example Output: The 100. element of the Fibonacci sequence is -1. + +``` diff --git a/generated/labs/backend.java.grundlagen.methods/pom.xml b/generated/labs/backend.java.grundlagen.methods/pom.xml new file mode 100644 index 0000000..41b8c00 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-02-03-08-methods + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..6bad907 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,22 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.FibonacciHelper; +import ch.itninja.labs.basicexercises.MessageHelper; +import ch.itninja.labs.basicexercises.NumberHelper; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + // Sample call for "Nachricht drucken" + // IT-Ninja: Füge hier Deinen Code ein... + + // Sample call for "Minimum von drei Zahlen" + // IT-Ninja: Füge hier Deinen Code ein... + + // Sample call for "Fibonacci" + // IT-Ninja: Füge hier Deinen Code ein... + } +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/FibonacciHelper.java b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/FibonacciHelper.java new file mode 100644 index 0000000..78e8501 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/FibonacciHelper.java @@ -0,0 +1,9 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for fibonacci operations. + */ +public class FibonacciHelper { + + // IT-Ninja: Füge hier Deinen Code ein... +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/MessageHelper.java b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/MessageHelper.java new file mode 100644 index 0000000..fda7c99 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/MessageHelper.java @@ -0,0 +1,9 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for fibonacci operations. + */ +public class MessageHelper { + + // IT-Ninja: Füge hier Deinen Code ein... +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java new file mode 100644 index 0000000..bc609fb --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/main/java/ch/itninja/labs/basicexercises/NumberHelper.java @@ -0,0 +1,9 @@ +package ch.itninja.labs.basicexercises; + +/** + * Utility class providing helper methods for fibonacci operations. + */ +public class NumberHelper { + + // IT-Ninja: Füge hier Deinen Code ein... +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/FibonacciHelperTest.java b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/FibonacciHelperTest.java new file mode 100644 index 0000000..5c72269 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/FibonacciHelperTest.java @@ -0,0 +1,47 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; + +public class FibonacciHelperTest { + + private static final int METHOD_NOT_IMPLEMENTED = -2; + + @ParameterizedTest + @CsvSource({ + "1, 0, 0", + "2, 1, 1", + "3, 2, 1", + "4, 7, 13", + "5, -5, 0", + "6, 100, -1", + }) + void testFibonacci(int lab, int n, int expected) { + + // Init to a number not used by the methode. + int fibonacci = METHOD_NOT_IMPLEMENTED; + + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: fibonacci = methode(n);): + // IT-Ninja: Füge hier Deinen Code ein... + } finally { + } + + // Pre-Check for implementation + assertNotEquals(METHOD_NOT_IMPLEMENTED , fibonacci + , "Please ensure that the method is called in try code block and the result is stored in variable 'fibonacci'!"); + + // THEN + assertEquals(expected, fibonacci, "The fibonacci number is not correct"); + + // For documentation + String input = String.format("fibonacci = yourImplementation(%d);", n); + String output = String.format("Example Output: The %d. element of the Fibonacci sequence is %d.%n", n, fibonacci); + + ItNinjaOutput.PrintItNinjaOutput("Fibonacci"+lab, input, output); + } +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/MessageHelperTest.java b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/MessageHelperTest.java new file mode 100644 index 0000000..61da719 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/MessageHelperTest.java @@ -0,0 +1,49 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; + +public class MessageHelperTest { + + @ParameterizedTest + @CsvSource({ + "1, 'Peter', 'Das Meeting beginnt um 9 Uhr.', 'Nachricht an Peter: Das Meeting beginnt um 9 Uhr.'", + "2, 'Linda', 'Bitte rufe Hans Mustermann zurück.', 'Nachricht an Linda: Bitte rufe Hans Mustermann zurück.'", + }) + void givenPrintMessage_whenCalled_thenOutputAsExpected(int lab, String name, String message, String expected) { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: methode(name, message);): + // IT-Ninja: Füge hier Deinen Code ein... + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + + // Pre-Check for implementation + assertNotEquals("" , output + , "Output empty. Please ensure that the method is called in try code block!"); + + assertEquals(expected, output, "Output is not as expected."); + + // For documentation + String input = String.format("yourImplementation(\"%s\", \"%s\");" + , name, message); + + ItNinjaOutput.PrintItNinjaOutput("PrintMessage"+lab, input, output); + } +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java new file mode 100644 index 0000000..a2dcc54 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/basicexercises/NumberHelperTest.java @@ -0,0 +1,44 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; + +public class NumberHelperTest { + + private static final int METHOD_NOT_IMPLEMENTED = -2; + + @ParameterizedTest + @CsvSource({ + "1, 63, 22, 98, 22", + "2, 17, 67, 32, 17", + "3, 4, 56, 3, 3", + }) + void givenMinimumOfThree_whenCalled_thenOutputAsExpected(int lab, int a, int b, int c, int expected) { + + // Init to a number not used by the methode. + int min = METHOD_NOT_IMPLEMENTED; + + try { + // WHEN + // Aufruf der Methode, welche wir testen wollen (etwas wie: min = methode(a, b, c);): + // IT-Ninja: Füge hier Deinen Code ein... + } finally { + } + + // Pre-Check for implementation + assertNotEquals(METHOD_NOT_IMPLEMENTED , min + , "Please ensure that the method is called in try code block and the result is stored in variable 'min'!"); + + // THEN + assertEquals(expected, min, "The number seems not to be the minimum of three."); + + // For documentation + String input = String.format("min = yourImplementation(%d, %d, %d);", a, b, c); + String output = String.format("Example Output: The minimum from %d, %d and %d is %d.%n", a, b, c, min); + + ItNinjaOutput.PrintItNinjaOutput("MinimumOfThree"+lab, input, output); + } +} diff --git a/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.methods/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.packages/.itninja.index.json b/generated/labs/backend.java.grundlagen.packages/.itninja.index.json new file mode 100644 index 0000000..480adc2 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/.itninja.index.json @@ -0,0 +1,25 @@ +{ + "generatedAt" : "2026-03-22T21:57:05.217080970Z", + "project" : "backend.java.grundlagen.packages", + "files" : [ { + "path" : "README.md", + "size" : 2341, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 250, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java", + "size" : 332, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.packages/README.md b/generated/labs/backend.java.grundlagen.packages/README.md new file mode 100644 index 0000000..c231087 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/README.md @@ -0,0 +1,68 @@ + + +# Java Exercises - Packages + +Mit diesen Übungen kannst du dein Wissen zum Thema Packages vertiefen. + +#### Voraussetzung + +- Du weisst was ein Package ist. + + + +## Aufgabe 1 + +Erstelle ein eigenes Package, welches dir ein paar mathematische Hilfsfunktionen zur Verfügung +stellt: + +* Kleinerer Wert von 2 Integerzahlen +* Grösserer Wert von 2 Integerzahlen +* Absoluter Wert von einer Integerzahl +* Abstand von 2 Integerzahlen + +**Achtung:** Das von dir erstellte Package darf nicht `ch.itninja.labs` enthalten. + +Passe main an, damit deine Package verwendet wird. Erstelle ein paar Aufrufe und gib das Resultat auf der Konsole aus. + +```java + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +## Aufgabe 2 + +Erstelle ein weiteres Package im gleichen Projekt, welches einen Zähler verwaltet. Der Zähler ist statisch und der +Datentyp soll int sein. Der Zähler kann mit folgenden Methoden verändert werden: + +* Increment -> Zähler um eins erhöhen +* Decrement -> Zähler um eins reduzieren +* Add -> Wert zu Zähler hinzufügen +* Subtract -> Wert vom Zähler abziehen. +* Reset -> Wert vom Zähler auf 0 setzen. + +Bei allen Operationen darf der Zähler den Bereich 0..1000 nicht verlassen. Würde bei einer Operation der Zähler den +Bereich verlassen, wird er auf die Grenze des Bereichs gesetzt (limitiert). + +**Achtung:** Das von dir erstellte Package darf nicht `ch.itninja.labs` enthalten. + +Passe main an, damit deine Package verwendet wird. Erstelle ein paar Aufrufe und gib das Resultat auf der Konsole aus. + +## Aufgabe 3 + +{{< ninja warning >}} +**Zusätzliche Vorbereitung:** +Erstelle 2 Kopien des IntelliJ-Projekts. Kopiere dazu den Ordner welcher das pom.xml beinhaltet. Normalerweise +sollte der Ordner `12_packages` heissen und die Kopie zum Beispiel `12_packages.create` und `12_packages.use`. +{{< /ninja >}} + +Passe die beiden Projekte so an, dass du mit dem Projekt `12_packages.create` ein Java Package erstellst und dieses im +Projekt `12_packages.use` verwendest. + +Es wird erwartet, dass dein Package JavaDoc beinhaltet. + +Am Ende der Übung soll deine Ausgabe auf der Konsole bei Aufgabe 3 dasselbe ausgeben, was auch bei Aufgabe 1 und 2 +ausgegeben wird. diff --git a/generated/labs/backend.java.grundlagen.packages/pom.xml b/generated/labs/backend.java.grundlagen.packages/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.packages/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.packages/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..8831c42 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,12 @@ +package ch.itninja.labs; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +} diff --git a/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java b/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java new file mode 100644 index 0000000..dc140b4 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java @@ -0,0 +1,14 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class EmptyTest { + @Test + void emptyTest() { + + // This is just a placeholder for upcoming tests. Required by LabGenerator + } +} diff --git a/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.packages/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/.itninja.index.json b/generated/labs/backend.java.grundlagen.regex/.itninja.index.json new file mode 100644 index 0000000..130bffa --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/.itninja.index.json @@ -0,0 +1,53 @@ +{ + "generatedAt" : "2026-03-22T21:57:00.748027257Z", + "project" : "backend.java.grundlagen.regex", + "files" : [ { + "path" : "README.md", + "size" : 4633, + "language" : "markdown" + }, { + "path" : "data/mixed.txt", + "size" : 449, + "language" : "text" + }, { + "path" : "pom.xml", + "size" : 1200, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/regex/RegexTasks.java", + "size" : 1925, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/ItNinjaOutput.java", + "size" : 793, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexChPlzTest.java", + "size" : 1097, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexEmailTest.java", + "size" : 1240, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexIbanTest.java", + "size" : 1164, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexMatcherUtil.java", + "size" : 564, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexPasswordTest.java", + "size" : 1108, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexPhoneTest.java", + "size" : 1195, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/regex/RegexUrlTest.java", + "size" : 1223, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.regex/README.md b/generated/labs/backend.java.grundlagen.regex/README.md new file mode 100644 index 0000000..c48137b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/README.md @@ -0,0 +1,153 @@ + + +# Java Exercises - Regex + +Mit diesen Übungen kannst du dein Wissen zum Thema Regex vertiefen. + +#### Voraussetzung + +- Ich kann mit Regex Zeichenketten im Text erkennen und extrahieren. +- Ich verstehe, wie man Regex schrittweise und sicher testet. + + + +## Aufgabe 1 - E-Mail-Adressen aus einem Text extrahieren +Schreibe eine Regex, die alle E-Mail-Adressen in einem Text findet. Nutze die bereitgestellte Beispieldatei `data/mixed.txt`. + + +- Beispieleingabe: `Meine Adresse: max.mustermann@example.com; Info: test@mail.de` +- Erwartete Treffer: `["max.mustermann@example.com", "test@mail.de"]` + +```java + /** + * Build a Pattern that matches email-like addresses. + * Tip: local-part + "@" + domain + TLD of length >= 2. + */ + public static Pattern buildEmailPattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +## Aufgabe 2 - IBAN formatvalidieren + +Validiere IBANs rein syntaktisch (ohne Mod-97-Prüfung). Akzeptiere optionale Leerzeichen zwischen Blöcken. + + +- Beispiele: `CH93 0076 2011 6238 5295 7`, `DE89 3704 0044 0532 0130 00` +- Hinweis: Landeskürzel (2 Grossbuchstaben), 2 Ziffern Prüfsumme, restliche Zeichen: A–Z oder 0–9. + +```java + /** + * Build a Pattern that matches IBANs syntactically with optional spaces. + * Examples: "CH93 0076 2011 6238 5295 7", "DE89 3704 0044 0532 0130 00" + * Note: Only format validation here, not the Mod-97 checksum. + */ + public static Pattern buildIbanPattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +## Aufgabe 3 - Telefonnummern (Schweiz und international) + +Erkenne Telefonnummern mit optionalem Ländercode (z. B. +41) und unterschiedlichen Trennzeichen (Leerzeichen, Punkt, Bindestrich). + + +- Beispiele: `+41 31 987 65 43`, `031 987 65 43` + +```java + /** + * Build a Pattern for (Swiss/international) phone numbers with optional country code + * and separators (space, dot, hyphen). Keep it reasonably permissive. + */ + public static Pattern buildPhonePattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +## Aufgabe 4 - URLs extrahieren + +Extrahiere http- und https-URLs aus einem Text, ohne ans Zeilenende zu laufen oder nachfolgende Satzzeichen mitzunehmen. + + +- Beispiele: `https://it-ninjas.ch`, `http://example.org/test` + +```java + /** + * Build a Pattern that captures http/https URLs without trailing punctuation. + */ + public static Pattern buildUrlPattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +## Aufgabe 5 - Passwort-Policy prüfen + +Mindestens 8 Zeichen, je 1 Klein- und Grossbuchstabe, 1 Ziffer, 1 Sonderzeichen. Prüfe mit einem einzigen Regex. + + +- Beispiel gültig: `SecuRe!234` +- Beispiel ungültig: `password1` + +```java + /** + * Build a Pattern enforcing: >= 8 chars, at least 1 lowercase, 1 uppercase, 1 digit, 1 symbol. + * Hint: lookaheads. + */ + public static Pattern buildPasswordPolicyPattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +### Aufgabe 6 - Schweizer Postleitzahlen (CH-PLZ) + +Erkenne CH-Postleitzahlen (genau 4 Ziffern, keine führende 0). Beachte, dass nach der PLZ eine Ortsbezeichnung kommen +muss. + + +- Beispiele gültig: `3007`, `1000` +- Beispiele ungültig: `0123`, `12345` + +```java + /** + * Build a Pattern that matches Swiss postal codes (4 digits, no leading zero). + */ + public static Pattern buildChPostalCodePattern() { + // TODO: implement + return Pattern.compile(""); + } +``` + +::src(src/main/java/ch/itninja/labs/regex/RegexTasks.java) + +--- + +## Hinweise + +- Teste deine Regex iterativ, nutze Raw-Strings (z. B. in Java `Pattern.compile("...")`) und kleine Testfälle. +- Achte darauf, bei Extraktion *nicht zu gierig* zu matchen und Mehrfachtreffer zu ermöglichen. +- Für IBANs ist eine vollständige Validierung inkl. Prüfziffernrechnung ausserhalb des Regex sinnvoll. diff --git a/generated/labs/backend.java.grundlagen.regex/data/mixed.txt b/generated/labs/backend.java.grundlagen.regex/data/mixed.txt new file mode 100644 index 0000000..1cea910 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/data/mixed.txt @@ -0,0 +1,6 @@ +Kontakt: max.mustermann@example.com, info@test.mail, support@sub.domain.co.uk +Telefone: +41 31 987 65 43, 031 987 65 43, +41-44-668-18-00 +URLs: https://it-ninjas.ch, http://example.org/test, https://sub.domain.tld/path?x=1#anchor. +IBANs: CH93 0076 2011 6238 5295 7, DE89370400440532013000, XX12 TEST 1234 +Passwörter: SecuRe!234, password1, N0SymbolsHere, Sh0rt! +PLZ: 3007 Bern (BE), 1000 Lausanne (VD), 0123 Silberwyl (GN), 12345 Sternenbrugg (TN) diff --git a/generated/labs/backend.java.grundlagen.regex/pom.xml b/generated/labs/backend.java.grundlagen.regex/pom.xml new file mode 100644 index 0000000..0a41f1b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/pom.xml @@ -0,0 +1,36 @@ + + 4.0.0 + ch.itninja.labs + regex-lab + 1.0-SNAPSHOT + + 21 + 21 + UTF-8 + 5.10.2 + + + + + org.junit.jupiter + junit-jupiter + ${junit.jupiter.version} + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + false + + + + + diff --git a/generated/labs/backend.java.grundlagen.regex/src/main/java/ch/itninja/labs/regex/RegexTasks.java b/generated/labs/backend.java.grundlagen.regex/src/main/java/ch/itninja/labs/regex/RegexTasks.java new file mode 100644 index 0000000..a784a3c --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/main/java/ch/itninja/labs/regex/RegexTasks.java @@ -0,0 +1,65 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import java.util.List; +import java.util.regex.Pattern; + +/** + * Regex tasks for learners. Methods are intentionally left unimplemented. + * Keep code/comments in English. Implement solutions inside the marked blocks. + */ +public class RegexTasks { + + /** + * Build a Pattern that matches email-like addresses. + * Tip: local-part + "@" + domain + TLD of length >= 2. + */ + public static Pattern buildEmailPattern() { + // TODO: implement + return Pattern.compile(""); + } + + /** + * Build a Pattern that matches IBANs syntactically with optional spaces. + * Examples: "CH93 0076 2011 6238 5295 7", "DE89 3704 0044 0532 0130 00" + * Note: Only format validation here, not the Mod-97 checksum. + */ + public static Pattern buildIbanPattern() { + // TODO: implement + return Pattern.compile(""); + } + + /** + * Build a Pattern for (Swiss/international) phone numbers with optional country code + * and separators (space, dot, hyphen). Keep it reasonably permissive. + */ + public static Pattern buildPhonePattern() { + // TODO: implement + return Pattern.compile(""); + } + + /** + * Build a Pattern that captures http/https URLs without trailing punctuation. + */ + public static Pattern buildUrlPattern() { + // TODO: implement + return Pattern.compile(""); + } + + /** + * Build a Pattern enforcing: >= 8 chars, at least 1 lowercase, 1 uppercase, 1 digit, 1 symbol. + * Hint: lookaheads. + */ + public static Pattern buildPasswordPolicyPattern() { + // TODO: implement + return Pattern.compile(""); + } + + /** + * Build a Pattern that matches Swiss postal codes (4 digits, no leading zero). + */ + public static Pattern buildChPostalCodePattern() { + // TODO: implement + return Pattern.compile(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/ItNinjaOutput.java new file mode 100644 index 0000000..f6bbc1b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/ItNinjaOutput.java @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import java.util.Collection; +import java.util.Objects; +import java.util.stream.Collectors; + +/** + * Prints well-formed blocks for the it-ninja generator. + * Keep console output stable and simple so the generator can parse it. + */ +public final class ItNinjaOutput { + + private ItNinjaOutput() {} + + public static void PrintItNinjaOutput(String lab, String input, Collection output) { + String outJoined = output == null ? "" : + output.stream().filter(Objects::nonNull).collect(Collectors.joining(", ")); + + System.out.println("" + input + ""); + System.out.println("" + outJoined + ""); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexChPlzTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexChPlzTest.java new file mode 100644 index 0000000..d1f0b15 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexChPlzTest.java @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexChPlzTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("3007", "1000")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void ch_plz_extraction(List expected) { + var text = readMixed(); + var p = RegexTasks.buildChPostalCodePattern(); + var matches = RegexMatcherUtil.findAll(p, text); + ItNinjaOutput.PrintItNinjaOutput("regex-ch-plz", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexEmailTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexEmailTest.java new file mode 100644 index 0000000..1623797 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexEmailTest.java @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexEmailTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("max.mustermann@example.com", + "info@test.mail", + "support@sub.domain.co.uk")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void email_extraction(List expected) { + var text = readMixed(); + var p = RegexTasks.buildEmailPattern(); + var matches = RegexMatcherUtil.findAll(p, text); + // Print for docs + ItNinjaOutput.PrintItNinjaOutput("regex-email", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexIbanTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexIbanTest.java new file mode 100644 index 0000000..cc9ed8b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexIbanTest.java @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexIbanTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("CH93 0076 2011 6238 5295 7", + "DE89370400440532013000")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void iban_format_validation(List expected) { + var text = readMixed(); + var p = RegexTasks.buildIbanPattern(); + var matches = RegexMatcherUtil.findAll(p, text); + ItNinjaOutput.PrintItNinjaOutput("regex-iban", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexMatcherUtil.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexMatcherUtil.java new file mode 100644 index 0000000..c7c3976 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexMatcherUtil.java @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** Utility to collect regex matches from a text. */ +public final class RegexMatcherUtil { + + private RegexMatcherUtil() {} + + public static List findAll(Pattern pattern, String text) { + List res = new ArrayList<>(); + Matcher m = pattern.matcher(text); + while (m.find()) { + res.add(m.group()); + } + return res; + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPasswordTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPasswordTest.java new file mode 100644 index 0000000..4742c35 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPasswordTest.java @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexPasswordTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("SecuRe!234")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void password_policy_matches(List expected) { + var text = readMixed(); + var p = RegexTasks.buildPasswordPolicyPattern(); + var matches = RegexMatcherUtil.findAll(p, text); + ItNinjaOutput.PrintItNinjaOutput("regex-password", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPhoneTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPhoneTest.java new file mode 100644 index 0000000..01f27b8 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexPhoneTest.java @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexPhoneTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("+41 31 987 65 43", + "031 987 65 43", + "+41-44-668-18-00")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void phone_extraction(List expected) { + var text = readMixed(); + var p = RegexTasks.buildPhonePattern(); + var matches = RegexMatcherUtil.findAll(p, text); + ItNinjaOutput.PrintItNinjaOutput("regex-phone", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexUrlTest.java b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexUrlTest.java new file mode 100644 index 0000000..bfc992e --- /dev/null +++ b/generated/labs/backend.java.grundlagen.regex/src/test/java/ch/itninja/labs/regex/RegexUrlTest.java @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT +package ch.itninja.labs.regex; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class RegexUrlTest { + + static String readMixed() { + try { + return Files.readString(Path.of("data/mixed.txt")); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + static Stream> expectedProvider() { + return Stream.of(List.of("https://it-ninjas.ch", + "http://example.org/test", + "https://sub.domain.tld/path?x=1#anchor")); + } + + @ParameterizedTest + @MethodSource("expectedProvider") + void url_extraction(List expected) { + var text = readMixed(); + var p = RegexTasks.buildUrlPattern(); + var matches = RegexMatcherUtil.findAll(p, text); + ItNinjaOutput.PrintItNinjaOutput("regex-url", text, matches); + assertEquals(expected, matches); + } +} diff --git a/generated/labs/backend.java.grundlagen.strings/.itninja.index.json b/generated/labs/backend.java.grundlagen.strings/.itninja.index.json new file mode 100644 index 0000000..6c0d0e6 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/.itninja.index.json @@ -0,0 +1,25 @@ +{ + "generatedAt" : "2026-03-22T21:57:09.709648739Z", + "project" : "backend.java.grundlagen.strings", + "files" : [ { + "path" : "README.md", + "size" : 2615, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 250, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java", + "size" : 332, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.strings/README.md b/generated/labs/backend.java.grundlagen.strings/README.md new file mode 100644 index 0000000..68c4451 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/README.md @@ -0,0 +1,95 @@ + + +# Java Exercises - Strings + +Mit diesen Übungen kannst du dein Wissen zum Thema Strings vertiefen. + +#### Voraussetzung + +- Du weisst was ein String ist. +- Du kannst eigene Packages und Methoden erstellen + + + +## Ausgangslage + +Du hast den folgenden String: + +``` +String poem = """ + Ein Ninja leise wie der Wind, + Seine Waffen stets geschwind. + "Shurikens" fliegen, scharf und schnell, + Klingen funkeln, furchterregend hell. + "Nunchakus" wirbeln im Tanz, + Mit jedem Schlag, im Vorteil er ganz. + Seine Waffen, geheim und klug, + Begleiten ihn bei jedem Zug."""; +``` + +{{< ninja info >}} +Schreibe für jede Aufgabe eine eigene Methode, welche den String als Parameter nimmt. +Passe die `main(...)` Methode an, um deinen Quellcode aufzurufen. +{{< /ninja >}} + +## Aufgabe 1 - Wörter zählen + +Gib in der Konsole die Anzahl Wörtern aus. Als Wort gilt alles was eine Folge von Buchstaben und Zahlen sind. + +{{< ninja warning >}} +Die Methode `String.split(...)` darf in dieser Aufgabe nicht verwendet werden. `String.split(...)` wird erst in einem +späteren Modul behandelt. +{{< /ninja >}} + +```java + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +## Aufgabe 2 - Grossbuchstaben + +Gib den Text in Grossbuchstaben aus. + +```java + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +## Aufgabe 3 - Punkte setzen +Gib den Text so aus, dass jedes Leerzeichen mit einem Punkt ersetzt wurde. + +```java + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) + +## Aufgabe 4 - Wort ausschneiden +Schneide das Wort “Shurikens” aus. Ermittle hierfür die Position des Wortes anhand des "-Zeichens. + +**Hinweis:** Die indexOf()-Methode bietet ein optionales Argument fromIndex an. Übergibst du die Position des ersten +Anführungszeichen + 1, dann wird die Position des zweiten zurückgegeben. + +{{< ninja warning >}} +Die Methode `String.replace(...)` darf in dieser Aufgabe nicht verwendet werden. +{{< /ninja >}} + +```java + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +``` + +::src(src/main/java/ch/itninja/labs/Main.java) diff --git a/generated/labs/backend.java.grundlagen.strings/pom.xml b/generated/labs/backend.java.grundlagen.strings/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.strings/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.strings/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..8831c42 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,12 @@ +package ch.itninja.labs; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + + public static void main(String[] args) { + + // IT-Ninja: rufe hier deine Methoden auf und gib die Resultate auf der Konsole aus + } +} diff --git a/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java b/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java new file mode 100644 index 0000000..dc140b4 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/basicexercises/EmptyTest.java @@ -0,0 +1,14 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class EmptyTest { + @Test + void emptyTest() { + + // This is just a placeholder for upcoming tests. Required by LabGenerator + } +} diff --git a/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.strings/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/.itninja.index.json b/generated/labs/backend.java.grundlagen.variable-and-types/.itninja.index.json new file mode 100644 index 0000000..ec5de5a --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/.itninja.index.json @@ -0,0 +1,37 @@ +{ + "generatedAt" : "2026-03-22T21:56:44.010127579Z", + "project" : "backend.java.grundlagen.variable-and-types", + "files" : [ { + "path" : "README.md", + "size" : 2564, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1386, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 336, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/HelloName.java", + "size" : 308, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/basicexercises/TravelReport.java", + "size" : 322, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/HelloNameTest.java", + "size" : 922, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/basicexercises/TravelReportTest.java", + "size" : 2067, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/README.md b/generated/labs/backend.java.grundlagen.variable-and-types/README.md new file mode 100644 index 0000000..6f20c7c --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/README.md @@ -0,0 +1,95 @@ + + +# Java Exercises - Variablen und primitive Datentypen + +Mit diesen Übungen kannst du dein Wissen über Variablen und primitive Datentypen vertiefen. + +#### Voraussetzung + +- Du weisst was Variablen sind. +- Du kannst eine Variable deklarieren und initialisieren. +- Du weisst was primitive Datentypen sind. +- Du weisst wie man Variablen formatiert auf der Konsole ausgibt. + + + +## Aufgabe 1 - Hello It-Ninja + +Erstelle eine Variable, welche deinen Namen beinhaltet. +Gib `Hello [name]` auf der Konsole aus. + +```java + public static void printHelloName(){ + + // IT-Ninja: Füge hier Deinen Code ein: + + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/HelloName.java) + +**Beispielausgabe:** + +```console +Hello It-Ninja +``` + +## Aufgabe 2 - Reise Report + +Gib den folgenden Text mit `System.out.printf(...)` aus. Ersetze die kursiv, fett dargestellten Werte im Logbuch durch +Variablen, welche du selber definieren musst. + +--- +Reise Report – **_Takeshi_**, Codename **_ShadowFox_** +Datum der Abreise: **_26. Juli 2025_** +Mission: **_Code-Review_** +Startpunkt: **_Lausanne_** +Zielort: **_St. Gallen_** +Abfahrt: **_06:14 Uhr_** +Ankunft: **_09:07 Uhr_** +Zwischenhalte: **_5_** +Reisekosten: **_51.80_** **_CHF_** + +**_ShadowFox_** nutzte die **_1. Klasse_** am **_26. Juli 2025_**, um sich auf den anstehenden **_Code-Review_** +vorzubereiten. Mit einem Akku-Ladestand von **_92%_** und **_2_** mitgeführten Laptops war **_er_** bestens gerüstet. +Die Mission wurde **_erfolgreich_** abgeschlossen. Die Reisekosten sind in **_CHF_**. + +--- + +Anforderungen: +- Verwende sinnvolle Datentypen (String, int, double, boolean) +- Nutze `printf` mit Formatangaben wie `%.2f`, `%d`, `%s`, `%%` +- Achte auf Lesbarkeit und saubere Struktur + +```java + public static void printTravelReport() { + + // IT-Ninja: Füge hier Deinen Code ein: + } +``` + +::src(src/main/java/ch/itninja/labs/basicexercises/TravelReport.java) + +**Beispiel:** + +Eingabe: + +```console +TravelReport.printTravelReport(); +``` + +Ausgabe: + +```console +Reise Report – Takeshi, Codename ShadowFox +Datum der Abreise: 26. Juli 2025 +Mission: Code-Review +Startpunkt: Lausanne +Zielort: St. Gallen +Abfahrt: 06:14 Uhr +Ankunft: 09:07 Uhr +Zwischenhalte: 5 +Reisekosten: 51.80 CHF + +ShadowFox nutzte die 1. Klasse am 26. Juli 2025, um sich auf die anstehende Code-Review vorzubereiten. Mit einem Akku-Ladestand von 92% und 2 mitgeführten Laptops war er bestens gerüstet. Die Mission wurde erfolgreich abgeschlossen. Die Reisekosten sind in CHF. +``` diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/pom.xml b/generated/labs/backend.java.grundlagen.variable-and-types/pom.xml new file mode 100644 index 0000000..ca47410 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/pom.xml @@ -0,0 +1,45 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-basicexercises + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/Main.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..796f530 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,15 @@ +package ch.itninja.labs; + +import ch.itninja.labs.basicexercises.HelloName; +import ch.itninja.labs.basicexercises.TravelReport; + +/** + * Entry point for the It-Ninja basic exercises. + */ +public class Main { + public static void main(String[] args) { + + HelloName.printHelloName(); + TravelReport.printTravelReport(); + } +} \ No newline at end of file diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/HelloName.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/HelloName.java new file mode 100644 index 0000000..b8d9fa5 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/HelloName.java @@ -0,0 +1,18 @@ +package ch.itninja.labs.basicexercises; + + +/** + * Utility class providing methods for basic Hello Name output. + */ +public class HelloName { + + private HelloName() { + // Prevent instantiation + } + + public static void printHelloName(){ + + // IT-Ninja: Füge hier Deinen Code ein... + + } +} diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/TravelReport.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/TravelReport.java new file mode 100644 index 0000000..c600d9e --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/main/java/ch/itninja/labs/basicexercises/TravelReport.java @@ -0,0 +1,16 @@ +package ch.itninja.labs.basicexercises; + +/** + * Gibt einen Reisebericht eines it-ninjas formatiert mit printf aus. + */ +public class TravelReport { + + private TravelReport() { + // Prevent instantiation + } + + public static void printTravelReport() { + + // IT-Ninja: Füge hier Deinen Code ein... + } +} diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/HelloNameTest.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/HelloNameTest.java new file mode 100644 index 0000000..c3c7d11 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/HelloNameTest.java @@ -0,0 +1,34 @@ +package ch.itninja.labs.basicexercises; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +class HelloNameTest { + + @Test + void givenPrintHelloName_whenCalled_thenOutputStartsWithHello() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + HelloName.printHelloName(); + } finally { + System.setOut(originalOut); + } + + // THEN + String output = outputStream.toString().trim(); + assertTrue(output.startsWith("Hello "), "Output should start with 'Hello '"); + + ItNinjaOutput.PrintItNinjaOutput("HelloName", "", output); + + } +} diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/TravelReportTest.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/TravelReportTest.java new file mode 100644 index 0000000..b1117f7 --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/basicexercises/TravelReportTest.java @@ -0,0 +1,55 @@ +package ch.itninja.labs.basicexercises; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TravelReportTest { + + @Test + void givenPrintTravelReport_whenCalled_thenOutputShowsExpectedReport() { + // GIVEN + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + PrintStream originalOut = System.out; + System.setOut(new PrintStream(outputStream)); + + try { + // WHEN + TravelReport.printTravelReport(); + } finally { + System.setOut(originalOut); + } + + // THEN + String expectedReport = new StringBuilder() + .append("Reise Report – Takeshi, Codename ShadowFox\n") + .append("Datum der Abreise: 26. Juli 2025\n") + .append("Mission: Code-Review\n") + .append("Startpunkt: Lausanne\n") + .append("Zielort: St. Gallen\n") + .append("Abfahrt: 06:14 Uhr\n") + .append("Ankunft: 09:07 Uhr\n") + .append("Zwischenhalte: 5\n") + .append("Reisekosten: 51.80 CHF\n\n") + .append("ShadowFox nutzte die 1. Klasse am 26. Juli 2025, um sich auf die anstehende Code-Review ") + .append("vorzubereiten. Mit einem Akku-Ladestand von 92% und 2 mitgeführten Laptops war er bestens ") + .append("gerüstet. Die Mission wurde erfolgreich abgeschlossen. Die Reisekosten sind in CHF.") + .toString(); + + // Make output independent of linux or windows line endings + String output = outputStream + .toString() + .trim() + .replaceAll("\r\n", "\n") + .replaceAll("\r", "\n"); + + assertEquals(expectedReport, output, "Output is not as expected"); + + ItNinjaOutput.PrintItNinjaOutput("TravelReport", "TravelReport.printTravelReport();", output); + + } +} diff --git a/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/backend.java.grundlagen.variable-and-types/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +} diff --git a/generated/labs/tools.java.secrets.simple-example/.gitignore b/generated/labs/tools.java.secrets.simple-example/.gitignore new file mode 100644 index 0000000..4c49bd7 --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/.gitignore @@ -0,0 +1 @@ +.env diff --git a/generated/labs/tools.java.secrets.simple-example/.itninja.index.json b/generated/labs/tools.java.secrets.simple-example/.itninja.index.json new file mode 100644 index 0000000..f221ecc --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/.itninja.index.json @@ -0,0 +1,33 @@ +{ + "generatedAt" : "2026-03-22T21:57:35.265761759Z", + "project" : "tools.java.secrets.simple-example", + "files" : [ { + "path" : ".gitignore", + "size" : 5, + "language" : "gitignore" + }, { + "path" : "README.md", + "size" : 1373, + "language" : "markdown" + }, { + "path" : "pom.xml", + "size" : 1723, + "language" : "xml" + }, { + "path" : "src/main/java/ch/itninja/labs/Main.java", + "size" : 309, + "language" : "java" + }, { + "path" : "src/main/java/ch/itninja/labs/secrets/Basic.java", + "size" : 750, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/secrets/BasicTest.java", + "size" : 666, + "language" : "java" + }, { + "path" : "src/test/java/ch/itninja/labs/util/ItNinjaOutput.java", + "size" : 435, + "language" : "java" + } ] +} \ No newline at end of file diff --git a/generated/labs/tools.java.secrets.simple-example/README.md b/generated/labs/tools.java.secrets.simple-example/README.md new file mode 100644 index 0000000..9a221ef --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/README.md @@ -0,0 +1,47 @@ + + +# Secrets - Geheimnisse sicher hinterlegen + +Dieses Beispiel zeigt, wie man Geheimnisse in einer Java Applikation sicher hinterlegen kann. + +## Voraussetzung + +- Du weisst, was mit Geheimnissen gemeint ist. +- Du weisst was Umgebungsvariablen sind. +- Du weisst was Maven ist und kannst Maven-Projekte aufsetzen. +- Du weisst wie man bei Maven ein Paket hinzufügt. + + + +## Übung + +Das Beispiel zeigt, wie ein Projekt korrekt aufgesetzt wird, damit es sicher in einem Git-Repository gesichert werden +kann. + +Schaue dir die Datei `.env.template` an und folge den Anweisungen dort. Ersetze dabei `das_geheimnis` mit +`mein_geheimnis`. + +{{< pom >}} + +```xml + + io.github.cdimascio + dotenv-java + 3.0.0 + +``` + +{{< /pom >}} + +Wenn Du alles korrekt erledigt hast, sollte der Unittest erfolgreich durchlaufen: + +``` +mvn test +``` + +{{< ninja tip>}} +Wenn du den Unittest anschaust, wirst du feststellen, dass auch dort nirgends das Geheimnis im Klartext steht. Um zu +testen, ob du das Geheimnis korrekt konfiguriert hast vergleichen wir es mit einem Hash. Der Hash kann nicht zurück in +einen Klartext verwandelt werden, aber mit der Funktion `match` kann man feststellen, ob ein Wert den gleich Hash +erzeugt und so verifizieren, ob der Wert korrekt ist. +{{< /ninja >}} diff --git a/generated/labs/tools.java.secrets.simple-example/pom.xml b/generated/labs/tools.java.secrets.simple-example/pom.xml new file mode 100644 index 0000000..378c4a5 --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/pom.xml @@ -0,0 +1,57 @@ + + 4.0.0 + ch.itninja + itninja-labs-01-security + 1.0.0 + + + UTF-8 + 21 + 21 + + + + + + io.github.cdimascio + dotenv-java + 3.0.0 + + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + + org.mindrot + jbcrypt + 0.4 + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.11.0 + + 17 + UTF-8 + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + diff --git a/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/Main.java b/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/Main.java new file mode 100644 index 0000000..81fb42f --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/Main.java @@ -0,0 +1,13 @@ +package ch.itninja.labs; + +import ch.itninja.labs.secrets.Basic; + +/** + * Entry point for the It-Ninja basic secret example. + */ +public class Main { + public static void main(String[] args) { + String secret = Basic.getSecret(); + System.out.println("Das Geheimnis ist: '" + secret + "'"); + } +} \ No newline at end of file diff --git a/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/secrets/Basic.java b/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/secrets/Basic.java new file mode 100644 index 0000000..c69abac --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/src/main/java/ch/itninja/labs/secrets/Basic.java @@ -0,0 +1,29 @@ +package ch.itninja.labs.secrets; + +import io.github.cdimascio.dotenv.Dotenv; +import java.util.MissingResourceException; + +public class Basic { + + private static final String API_KEY_NAME = "SAMPLE_API_KEY"; + + private Basic() { + // Prevent instantiation + } + + public static String getSecret (){ + Dotenv dotenv = Dotenv.configure() + .ignoreIfMissing() + .load(); + + String apiKey = dotenv.get(API_KEY_NAME); + if (apiKey == null) { + throw new MissingResourceException( + "API key not set. Please check your .env file or environment variables.", + API_KEY_NAME, + null + ); + } + return apiKey; + } +} diff --git a/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/secrets/BasicTest.java b/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/secrets/BasicTest.java new file mode 100644 index 0000000..8324ccc --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/secrets/BasicTest.java @@ -0,0 +1,25 @@ +package ch.itninja.labs.secrets; + +import ch.itninja.labs.util.ItNinjaOutput; +import org.junit.jupiter.api.Test; +import org.mindrot.jbcrypt.BCrypt; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +class BasicTest { + + @Test + void givenBasicExample_whenCalled_thenReturnSecret() { + // GIVEN + String output = "Das Geheimnis ist: "; + String hash = "$2a$10$HidiMxXZdm1KEIT1nqGoHeiQoiruQd0VrL8I6yz6L.DucmcKjXp2."; + + // WHEN + String secret = Basic.getSecret(); + + // THEN + assertTrue(BCrypt.checkpw(secret, hash)); + + ItNinjaOutput.PrintItNinjaOutput("Basic", "", output + "'" + secret + "'"); + } +} diff --git a/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java b/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java new file mode 100644 index 0000000..d189f3b --- /dev/null +++ b/generated/labs/tools.java.secrets.simple-example/src/test/java/ch/itninja/labs/util/ItNinjaOutput.java @@ -0,0 +1,12 @@ +package ch.itninja.labs.util; + +public class ItNinjaOutput { + public static void PrintItNinjaOutput(String lab, String input, String output) { + System.out.println(""); + System.out.println(input); + System.out.println(""); + System.out.println(""); + System.out.println(output); + System.out.println(""); + } +}