refactored testing

src/test/oop/ch03/chess/ChessTest.java

@@ -0,0 +1,168 @@
+package oop.ch03.chess;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import static org.junit.Assert.assertEquals;
+
+public class ChessTest {
+    // Das Zeilenende wird auf Windows-Systemen anders codiert als auf Nicht-Windows-Systemen.
+    // Die folgende Zeile ermittelt die aktuelle Codierung.
+    // EOL = "End of Line"
+    private static final String LS = System.lineSeparator();
+    private static final String HE = "    1   2   3   4   5   6   7   8" + LS;
+    private static final String LI = "  +---+---+---+---+---+---+---+---+" + LS;
+    private static final String EMP = " |   |   |   |   |   |   |   |   |" + LS;
+    private static final String WK1 = " | n |   |   |   |   |   |   |   |" + LS;
+    private static final String WQ3 = " |   |   | q |   |   |   |   |   |" + LS;
+    private static final String CO1 = " |   |   | n |   | N | Q |   |   |" + LS;
+    private static final String INIT_BOARD = board(EMP, EMP, EMP, EMP, EMP, EMP, EMP, EMP);
+    private static final String WK61_BOARD = board(EMP, EMP, EMP, EMP, EMP, WK1, EMP, EMP);
+    private static final String APP1_BOARD = board(EMP, EMP, EMP, EMP, WQ3, CO1, EMP, EMP);
+    private static final String CHECK_TEXT1 = "white queen at (4, 2)" + LS +
+                                              "   cannot capture black queen at (8, 6)" + LS +
+                                              "   cannot capture white knight at (6, 4)" + LS +
+                                              "black queen at (8, 6)" + LS +
+                                              "   cannot capture white queen at (4, 2)" + LS +
+                                              "   can capture white knight at (6, 4)" + LS +
+                                              "white knight at (6, 4)" + LS +
+                                              "   cannot capture white queen at (4, 2)" + LS +
+                                              "   cannot capture black queen at (8, 6)" + LS;
+    private static final String CHECK_TEXT2 = "white knight at (6, 3)" + LS +
+                                              "   cannot capture black knight at (6, 5)" + LS +
+                                              "   cannot capture black queen at (6, 6)" + LS +
+                                              "   cannot capture white queen at (5, 3)" + LS +
+                                              "black knight at (6, 5)" + LS +
+                                              "   cannot capture white knight at (6, 3)" + LS +
+                                              "   cannot capture black queen at (6, 6)" + LS +
+                                              "   can capture white queen at (5, 3)" + LS +
+                                              "black queen at (6, 6)" + LS +
+                                              "   cannot capture white knight at (6, 3)" + LS +
+                                              "   cannot capture black knight at (6, 5)" + LS +
+                                              "   cannot capture white queen at (5, 3)" + LS +
+                                              "white queen at (5, 3)" + LS +
+                                              "   cannot capture white knight at (6, 3)" + LS +
+                                              "   cannot capture black knight at (6, 5)" + LS +
+                                              "   cannot capture black queen at (6, 6)" + LS;
+
+    private static String board(String... s) {
+        if (s.length != 8)
+            throw new IllegalArgumentException("Expected 8, but got " + s.length + " arguments");
+        StringBuilder sb = new StringBuilder();
+        sb.append(HE).append(LI);
+        for (int i = 1; i <= 8; i++)
+            sb.append(i).append(s[i - 1]).append(LI);
+        return sb.toString();
+    }
+
+    private Board board;
+
+    private final ByteArrayOutputStream printed = new ByteArrayOutputStream();
+    private final PrintStream printStream = new PrintStream(printed, true);
+
+    @Before
+    public void setup() {
+        board = new Board();
+        printed.reset();
+        System.setOut(printStream);
+    }
+
+    @After
+    public void tearDown() {
+        printStream.close();
+    }
+
+    @Test
+    public void testEmpty() {
+        board.printBoard();
+        assertEquals(INIT_BOARD, printed.toString());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidPos1() {
+        new Knight(Color.white, board, 0, 4);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidPos2() {
+        new Queen(Color.white, board, 0, 4);
+    }
+
+    @Test
+    public void testWhiteknight() {
+        final Piece knight = new Knight(Color.white, board, 6, 1);
+        checkPieces(1);
+        assertEquals(knight, board.pieceAt(6, 1));
+        board.printBoard();
+        assertEquals(WK61_BOARD, printed.toString());
+    }
+
+    @Test
+    public void test3Pieces() {
+        final Piece queen1 = new Queen(Color.white, board, 4, 2);
+        final Piece queen2 = new Queen(Color.black, board, 8, 6);
+        final Piece knight = new Knight(Color.white, board, 6, 4);
+        Assert.assertFalse(queen1.canCapture(queen2));
+        Assert.assertFalse(queen1.canCapture(knight));
+        Assert.assertFalse(queen2.canCapture(queen1));
+        Assert.assertTrue(queen2.canCapture(knight));
+        Assert.assertFalse(knight.canCapture(queen1));
+        Assert.assertFalse(knight.canCapture(queen2));
+        checkPieces(3);
+        assertEquals(queen1, board.pieceAt(4, 2));
+        assertEquals(queen2, board.pieceAt(8, 6));
+        assertEquals(knight, board.pieceAt(6, 4));
+        board.check();
+        assertEquals(CHECK_TEXT1, printed.toString());
+    }
+
+    @Test
+    public void test4Pieces() {
+        final Piece knight1 = new Knight(Color.white, board, 6, 3);
+        final Piece knight2 = new Knight(Color.black, board, 6, 5);
+        final Piece queen1 = new Queen(Color.black, board, 6, 6);
+        final Piece queen2 = new Queen(Color.white, board, 5, 3);
+        checkPieces(4);
+        assertEquals(knight1, board.pieceAt(6, 3));
+        assertEquals(knight2, board.pieceAt(6, 5));
+        assertEquals(queen1, board.pieceAt(6, 6));
+        assertEquals(queen2, board.pieceAt(5, 3));
+        board.printBoard();
+        assertEquals(APP1_BOARD, printed.toString());
+        Assert.assertFalse(knight1.canCapture(knight2));
+        Assert.assertFalse(knight1.canCapture(queen1));
+        Assert.assertFalse(knight1.canCapture(queen2));
+        Assert.assertFalse(knight2.canCapture(knight1));
+        Assert.assertFalse(knight2.canCapture(queen1));
+        Assert.assertTrue(knight2.canCapture(queen2));
+        Assert.assertFalse(queen1.canCapture(knight1));
+        Assert.assertFalse(queen1.canCapture(knight2));
+        Assert.assertFalse(queen1.canCapture(queen2));
+        Assert.assertFalse(queen2.canCapture(knight1));
+        Assert.assertFalse(queen2.canCapture(knight2));
+        Assert.assertFalse(queen2.canCapture(queen1));
+        printed.reset();
+        board.check();
+        assertEquals(CHECK_TEXT2, printed.toString());
+    }
+
+    private void checkPieces(int expectedNumPieces) {
+        int numPieces = 0;
+        for (int row = 1; row < 9; row++)
+            for (int col = 1; col < 9; col++)
+                if (board.pieceAt(row, col) != null)
+                    numPieces++;
+        assertEquals(expectedNumPieces, numPieces);
+    }
+
+    @Test
+    public void testRunWithErrors() {
+        final Piece rook = new Rook(Color.white, board, 1, 1);
+        assertEquals(rook, board.pieceAt(1, 1));
+    }
+}

src/test/oop/ch05/generic/mensa/MensaTest.java

@@ -0,0 +1,80 @@
+package oop.ch05.generic.mensa;
+
+import oop.ch05.generic.secured.AuthorizationException;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+public class MensaTest {
+    private static final String CONF_ACCOUNT = "33-1298";
+    private static final String OTHER_ACCOUNT = "33-1299";
+    private AccountManagement accountMgt;
+    private VendingMachine vm1;
+    private VendingMachine vm2;
+    private VendingMachine tumVM;
+    private CashPoint unibwMensa;
+
+    private AccountCard conf;
+    private MensaCard frankSmith;
+    private CashCard hansMueller;
+    private CashCard peterSchmidt;
+    private CashCard thomasMayer;
+
+    @Before
+    public void setup() {
+        accountMgt = new AccountManagement(4711, "UniBw admin");
+
+        vm1 = new VendingMachine("left", 4711);
+        vm2 = new VendingMachine("right", 4711);
+        tumVM = new VendingMachine("TUM Mensa", 3141);
+        unibwMensa = new CashPoint("UniBw Mensa", 4711, accountMgt);
+
+        conf = new AccountCard("conference", CONF_ACCOUNT, 42);
+        frankSmith = new CountCard("Frank Smith", Color.gray);
+        hansMueller = new CashCard("Hans Müller", Color.green, 4711);
+        peterSchmidt = new CashCard("Peter Schmidt", Color.green, 4711);
+        thomasMayer = new CashCard("Thomas Mayer", Color.blue, 4711);
+    }
+
+    @Test
+    public void testPayment() throws AuthorizationException, RejectedException {
+        vm1.deposit(hansMueller, 10);
+        vm1.deposit(peterSchmidt, 5);
+        vm2.deposit(thomasMayer, 2);
+        assertThrows(AuthorizationException.class, () -> tumVM.deposit(hansMueller, 10));
+
+        assertEquals(15, vm1.getEuros());
+        assertEquals(2, vm2.getEuros());
+        assertEquals(0, tumVM.getEuros());
+        assertEquals(1000, hansMueller.getBalance());
+        assertEquals(500, peterSchmidt.getBalance());
+        assertEquals(200, thomasMayer.getBalance());
+
+        hansMueller.pass(unibwMensa);
+        assertEquals(733, hansMueller.getBalance());
+        assertEquals(1, unibwMensa.getCounter());
+        assertEquals(267, unibwMensa.getCents());
+
+        frankSmith.pass(unibwMensa);
+        assertEquals(0, accountMgt.getAmount(CONF_ACCOUNT));
+        assertThrows(RejectedException.class, () -> conf.pass(unibwMensa));
+        assertThrows(RejectedException.class, () -> thomasMayer.pass(unibwMensa));
+        hansMueller.pass(unibwMensa);
+        hansMueller.pass(unibwMensa);
+        assertEquals(199, hansMueller.getBalance());
+
+        assertThrows(RejectedException.class, () -> hansMueller.pass(unibwMensa));
+
+        accountMgt.deposit(CONF_ACCOUNT, 1000);
+        accountMgt.deposit(OTHER_ACCOUNT, 2000);
+        assertEquals(100000, accountMgt.getAmount(CONF_ACCOUNT));
+        assertEquals(200000, accountMgt.getAmount(OTHER_ACCOUNT));
+
+        conf.pass(unibwMensa);
+        assertEquals(99505, accountMgt.getAmount(CONF_ACCOUNT));
+        assertEquals(200000, accountMgt.getAmount(OTHER_ACCOUNT));
+        assertEquals(5, unibwMensa.getCounter());
+    }
+}

src/test/oop/ch08/gui/mvc/TestModel.java

@@ -0,0 +1,24 @@
+package oop.ch08.gui.mvc;
+
+import oop.ch08.gui.mvc.model.CounterModel;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestModel {
+  @Test
+  public void testInitWithZero() {
+    final CounterModel model = new CounterModel();
+    assertEquals(0, model.getCounter());
+  }
+
+  @Test
+  public void testInc() {
+    final CounterModel model = new CounterModel();
+    int counter = model.getCounter();
+    model.increment();
+    assertEquals(++counter, model.getCounter());
+    model.increment();
+    assertEquals(++counter, model.getCounter());
+  }
+}

src/test/oop/ch09/calc/test/AdHocCalculatorEdgeTest.java

@@ -0,0 +1,280 @@
+package oop.ch09.calc.test;
+
+import oop.ch06.calc.AdHocCalculator;
+import oop.ch06.calc.Ops;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class AdHocCalculatorEdgeTest {
+  private AdHocCalculator calc;
+
+  @Before
+  public void setup() {
+    calc = new AdHocCalculator();
+    calc.digit(6);
+    calc.binOp(Ops.MULT);
+    calc.digit(7);
+    calc.eval();
+  }
+
+  @Test
+  public void test0() {
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+    calc.digit(6);
+    assertEquals(6.0, calc.getValue(), 1e-10);
+    calc.digit(2);
+    assertEquals(62.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(62.0, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+    calc.unOp(Ops.EXP);
+    assertEquals(1.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+    calc.binOp(Ops.MINUS);
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test1() {
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.SQRT);
+    assertEquals(6.48074069840786, calc.getValue(), 1e-10);
+    calc.unOp(Ops.SQRT);
+    assertEquals(2.5457298950218306, calc.getValue(), 1e-10);
+    calc.digit(8);
+    assertEquals(8.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(5.25, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test2() {
+    calc.binOp(Ops.PLUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test3() {
+    calc.binOp(Ops.MULT);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test4() {
+    calc.binOp(Ops.PLUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+    calc.digit(5);
+    assertEquals(5.0, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test5() {
+    calc.digit(6);
+    assertEquals(6.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test6() {
+    calc.digit(3);
+    assertEquals(3.0, calc.getValue(), 1e-10);
+    calc.binOp(Ops.DIV);
+    assertEquals(3.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test7() {
+    calc.digit(7);
+    assertEquals(7.0, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test8() {
+    calc.digit(9);
+    assertEquals(9.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(9.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test9() {
+    calc.digit(5);
+    assertEquals(5.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.CHANGE_SIGN);
+    assertEquals(-5.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test11() {
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.binOp(Ops.PLUS);
+    assertEquals(0.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test12() {
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.digit(2);
+    assertEquals(0.2, calc.getValue(), 1e-10);
+    calc.unOp(Ops.EXP);
+    assertEquals(1.2214027581601699, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test13() {
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test14() {
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.SQRT);
+    assertEquals(6.48074069840786, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test15() {
+    calc.binOp(Ops.MINUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.EXP);
+    assertEquals(1.73927494152050099E18, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(-1.73927494152050099E18, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test16() {
+    calc.binOp(Ops.MINUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.EXP);
+    assertEquals(1.73927494152050099E18, calc.getValue(), 1e-10);
+    calc.binOp(Ops.MINUS);
+    assertEquals(-1.73927494152050099E18, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test17() {
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.EXP);
+    assertEquals(1.73927494152050099E18, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test18() {
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.SQRT);
+    assertEquals(6.48074069840786, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.binOp(Ops.PLUS);
+    assertTrue(Double.isNaN(calc.getValue()));
+  }
+
+  @Test
+  public void test19() {
+    calc.binOp(Ops.DIV);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.digit(2);
+    assertEquals(2.0, calc.getValue(), 1e-10);
+    calc.digit(5);
+    assertEquals(25.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.CHANGE_SIGN);
+    assertEquals(-25.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test20() {
+    calc.binOp(Ops.PLUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.digit(9);
+    assertEquals(9.0, calc.getValue(), 1e-10);
+    calc.binOp(Ops.PLUS);
+    assertEquals(51.0, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test21() {
+    calc.binOp(Ops.MULT);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.digit(7);
+    assertEquals(7.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(7.0, calc.getValue(), 1e-10);
+    calc.unOp(Ops.SQRT);
+    assertEquals(2.6457513110645907, calc.getValue(), 1e-10);
+  }
+
+  @Test
+  public void test22() {
+    calc.binOp(Ops.PLUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.digit(3);
+    assertEquals(3.0, calc.getValue(), 1e-10);
+    calc.allClear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test23() {
+    calc.binOp(Ops.MULT);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.digit(3);
+    assertEquals(0.3, calc.getValue(), 1e-10);
+    calc.clear();
+    assertEquals(0.0, calc.getValue(), 1e-20);
+  }
+
+  @Test
+  public void test24() {
+    calc.binOp(Ops.PLUS);
+    assertEquals(42.0, calc.getValue(), 1e-10);
+    calc.dot();
+    assertEquals(0.0, calc.getValue(), 1e-10);
+    calc.eval();
+    assertEquals(42.0, calc.getValue(), 1e-10);
+  }
+}

src/test/oop/ch09/testing/ExceptionTest.java

@@ -0,0 +1,34 @@
+package oop.ch09.testing;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public class ExceptionTest {
+  @Test
+  public void testDivZero1() {
+    int zero = 0;
+    int result = 4 / zero;
+    assertTrue(true);
+  }
+
+  @Test
+  public void testDivZero2() {
+    int zero = 0;
+    try {
+      int result = 4 / zero;
+      fail("ArithmeticException kam nicht");
+    }
+    catch (ArithmeticException ex) {
+      assertEquals("/ by zero", ex.getMessage());
+    }
+  }
+
+  @Test(expected = ArithmeticException.class)
+  public void testDivZero2b() {
+    int zero = 0;
+    int result = 4 / zero;
+  }
+}

src/test/uebung/uebung04/tournament/TournamentTest.java

@@ -0,0 +1,134 @@
+package test.uebung.uebung04.tournament;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+public class TournamentTest {
+
+    private static final String BORGHOFF = "Prof. Borghoff";
+    private static final String HOMMEL = "Prof. Hommel";
+    private static final String KOCH = "Prof. Koch";
+    private static final String MINAS = "Prof. Minas";
+    private static final String BUCHENRIEDER = "Prof. Buchenrieder";
+    private static final String DREO = "Prof. Dreo";
+    private static final String ROSE = "Prof. Rose";
+    private static final String SIEGLE = "Prof. Siegle";
+    private static final String TEEGE = "Prof. Teege";
+    private static final Set<String> SET1 = Set.of(BORGHOFF, HOMMEL, KOCH, MINAS, BUCHENRIEDER, DREO, ROSE, SIEGLE, TEEGE);
+    private static final Set<String> SET2 = Set.of(BORGHOFF, MINAS, SIEGLE, HOMMEL, DREO);
+    private static final Set<String> SET3 = Set.of(BORGHOFF, MINAS, SIEGLE);
+    private static final Set<String> SET4 = Set.of(MINAS, SIEGLE);
+    private static final Set<String> SET5 = Set.of(MINAS);
+
+    private Tournament tournament;
+    private Game r1s1;
+    private Game r1s2;
+    private Game r1s3;
+    private Game r1s4;
+    private Game r2s1;
+    private Game r2s2;
+    private Game r3s1;
+    private Game r4s1;
+
+    @Before
+    public void setup() {
+        r1s1 = new SeededGame(HOMMEL, KOCH);
+        r1s2 = new SeededGame(MINAS, BUCHENRIEDER);
+        r1s3 = new SeededGame(DREO, ROSE);
+        r1s4 = new SeededGame(SIEGLE, TEEGE);
+        r2s1 = new ByeGame(BORGHOFF, r1s1);
+        r2s2 = new OrdinaryGame(r1s2, r1s3);
+        r3s1 = new OrdinaryGame(r2s1, r2s2);
+        r4s1 = new OrdinaryGame(r3s1, r1s4);
+        tournament = new Tournament("UniBw Sportschießen", r4s1);
+    }
+
+    @Test
+    public void testBeforeFirstRound() {
+        assertEquals(SET1, asSet(tournament.getAllPlayers()));
+        assertEquals(SET1, asSet(tournament.getRemainingPlayers()));
+    }
+
+    @Test
+    public void testFirstRound() {
+        r1s1.setWinner(HOMMEL);
+        r1s2.setWinner(MINAS);
+        r1s3.setWinner(DREO);
+        r1s4.setWinner(SIEGLE);
+        assertEquals(SET1, asSet(tournament.getAllPlayers()));
+        assertEquals(SET2, asSet(tournament.getRemainingPlayers()));
+    }
+
+    @Test
+    public void testSecondRound() {
+        r1s1.setWinner(HOMMEL);
+        r1s2.setWinner(MINAS);
+        r1s3.setWinner(DREO);
+        r1s4.setWinner(SIEGLE);
+        r2s1.setWinner(BORGHOFF);
+        r2s2.setWinner(MINAS);
+        assertEquals(SET1, asSet(tournament.getAllPlayers()));
+        assertEquals(SET3, asSet(tournament.getRemainingPlayers()));
+    }
+
+    @Test
+    public void testThirdRound() {
+        r1s1.setWinner(HOMMEL);
+        r1s2.setWinner(MINAS);
+        r1s3.setWinner(DREO);
+        r1s4.setWinner(SIEGLE);
+        r2s1.setWinner(BORGHOFF);
+        r2s2.setWinner(MINAS);
+        r3s1.setWinner(MINAS);
+        assertEquals(SET1, asSet(tournament.getAllPlayers()));
+        assertEquals(SET4, asSet(tournament.getRemainingPlayers()));
+    }
+
+    @Test
+    public void testCompleteTournament() {
+        r1s1.setWinner(HOMMEL);
+        r1s2.setWinner(MINAS);
+        r1s3.setWinner(DREO);
+        r1s4.setWinner(SIEGLE);
+        r2s1.setWinner(BORGHOFF);
+        r2s2.setWinner(MINAS);
+        r3s1.setWinner(MINAS);
+        r4s1.setWinner(MINAS);
+        assertEquals(SET1, asSet(tournament.getAllPlayers()));
+        assertEquals(SET5, asSet(tournament.getRemainingPlayers()));
+    }
+
+    @Test
+    public void testException() {
+        r1s1.setWinner(HOMMEL);
+        r1s2.setWinner(MINAS);
+        r1s3.setWinner(DREO);
+        r1s4.setWinner(SIEGLE);
+        r2s1.setWinner(BORGHOFF);
+        r2s2.setWinner(MINAS);
+        r3s1.setWinner(MINAS);
+        assertThrows(IllegalArgumentException.class, () -> r4s1.setWinner(BUCHENRIEDER));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testException2() {
+        r4s1.setWinner(MINAS);
+    }
+
+    @Test
+    public void testException3() {
+        r1s1.setWinner(HOMMEL);
+        assertThrows(IllegalStateException.class, () -> r1s1.setWinner(HOMMEL));
+    }
+
+    private static <T> Set<T> asSet(Collection<T> collection) {
+        return new HashSet<>(collection);
+    }
+}

src/test/uebung/uebung05/logistics/ManagerTest.java

@@ -0,0 +1,67 @@
+package logistics;
+
+import logistics.material.BulletBelts;
+import logistics.material.Grease;
+import logistics.material.LiterDiesel;
+import logistics.material.MetGallonsKerosene;
+import logistics.material.Oil;
+import logistics.material.RocketPods;
+import logistics.material.ShellBatches;
+import logistics.quantities.NeedCollector;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ManagerTest {
+    private static final float EPS = 1e-5f;
+    private Manager manager;
+
+    @Before
+    public void setup() {
+        manager = new Manager();
+        manager.addVehicle(new Tank("Leo1"));
+        manager.addVehicle(new Tank("Leo2"));
+        manager.addVehicle(new Helicopter("Tiger1"));
+        manager.addVehicle(new Helicopter("Tiger2"));
+    }
+
+    @Test
+    public void testInitialNeed() {
+        final NeedCollector collector = manager.collectNeeds();
+        assertEquals(4, collector.getNeed(RocketPods.INSTANCE));
+        assertEquals(12, collector.getNeed(Oil.INSTANCE));
+        assertEquals(24, collector.getNeed(BulletBelts.INSTANCE));
+        assertEquals(20, collector.getNeed(ShellBatches.INSTANCE));
+        assertEquals(12, collector.getNeed(Grease.INSTANCE));
+        assertEquals(1000f, collector.getNeed(MetGallonsKerosene.INSTANCE), EPS);
+        assertEquals(2400f, collector.getNeed(LiterDiesel.INSTANCE), EPS);
+    }
+
+    @Test
+    public void testNeedAfterFillUp() {
+        manager.fillUpVehicles();
+        final NeedCollector collector = manager.collectNeeds();
+        assertEquals(0, collector.getNeed(RocketPods.INSTANCE));
+        assertEquals(0, collector.getNeed(Oil.INSTANCE));
+        assertEquals(0, collector.getNeed(BulletBelts.INSTANCE));
+        assertEquals(0, collector.getNeed(ShellBatches.INSTANCE));
+        assertEquals(0, collector.getNeed(Grease.INSTANCE));
+        assertEquals(0f, collector.getNeed(MetGallonsKerosene.INSTANCE), EPS);
+        assertEquals(0f, collector.getNeed(LiterDiesel.INSTANCE), EPS);
+    }
+
+    @Test
+    public void testNeedAfterLogTick() {
+        manager.fillUpVehicles();
+        manager.logTick(1);
+        final NeedCollector collector = manager.collectNeeds();
+        assertEquals(2, collector.getNeed(RocketPods.INSTANCE));
+        assertEquals(4, collector.getNeed(Oil.INSTANCE));
+        assertEquals(6, collector.getNeed(BulletBelts.INSTANCE));
+        assertEquals(4, collector.getNeed(ShellBatches.INSTANCE));
+        assertEquals(4, collector.getNeed(Grease.INSTANCE));
+        assertEquals(100f, collector.getNeed(MetGallonsKerosene.INSTANCE), EPS);
+        assertEquals(360f, collector.getNeed(LiterDiesel.INSTANCE), EPS);
+    }
+}

src/test/uebung/uebung05/logistics/storage/IntStorageTest.java

@@ -0,0 +1,80 @@
+package test.uebung.uebung05.logistics.storage;
+
+import uebung05.*;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class IntStorageTest {
+    private static final int MAX = 3;
+
+    private IntStorage intStorage;
+
+    @Before
+    public void setup() {
+        intStorage = new IntStorage(0, Oil.INSTANCE, MAX);
+    }
+
+    @Test
+    public void testEmptyStorage() {
+        assertEquals(0, intStorage.getStored());
+    }
+
+    @Test
+    public void testGetStorage() {
+        intStorage.fill(1);
+        assertEquals(1, intStorage.getStored());
+    }
+
+    @Test
+    public void testGetMax() {
+        assertEquals(MAX, intStorage.getMax());
+    }
+
+    @Test
+    public void testFillUp() {
+        intStorage.fillUp();
+        assertEquals(MAX, intStorage.getStored());
+    }
+
+    @Test
+    public void testUpperBound() {
+        intStorage.fill(MAX + 1);
+        assertEquals(MAX, intStorage.getStored());
+    }
+
+    @Test
+    public void testConsume() {
+        intStorage.fillUp();
+        assertEquals(MAX, intStorage.getStored());
+        assertEquals(MAX, intStorage.consume(MAX));
+    }
+
+    @Test
+    public void testLowerBound() {
+        intStorage.consume(1);
+        assertEquals(0, intStorage.getStored());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIllegalFill() {
+        intStorage.fill(-1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIllegalConsume() {
+        intStorage.consume(-1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testIllegalLowerBoundConstructor() {
+        new IntStorage(-1, Oil.INSTANCE, MAX);
+    }
+
+    @Test
+    public void testUpperBoundConstructor() {
+        final IntStorage storage = new IntStorage(MAX + 1, Oil.INSTANCE, MAX);
+        assertEquals(MAX, storage.getStored());
+    }
+}

src/test/uebung/uebung09/iterator/Array2dIteratorTest.java

@@ -0,0 +1,44 @@
+package test.uebung.uebung09.iterator;
+
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import uebung09.iterator.Array2dIterator;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+public class Array2dIteratorTest {
+    @Test
+    public void testArray2dIterator() {
+        final String[][] array = {{}, {"foo", "bar"}, {"baz"}, {}};
+        final Iterator<String> it = new Array2dIterator<>(array);
+        assertTrue(it.hasNext());
+        assertEquals("foo", it.next());
+        assertTrue(it.hasNext());
+        assertEquals("bar", it.next());
+        assertTrue(it.hasNext());
+        assertEquals("baz", it.next());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testArray2dIteratorOnlyEmpty() {
+        final String[][] array = {{}, {}, {}};
+        final Iterator<String> it = new Array2dIterator<>(array);
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testArray2dIteratorEmpty() {
+        final String[][] array = {};
+        final Iterator<String> it = new Array2dIterator<>(array);
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+}

src/test/uebung/uebung09/iterator/SkipNullIteratorTest.java

@@ -0,0 +1,124 @@
+package test.uebung.uebung09.iterator;
+
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import uebung09.iterator.*;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+public class SkipNullIteratorTest {
+    @Test
+    public void testEmpty() {
+        final Iterator<Object> it = new SkipNullIterator<>(emptyList().iterator());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testNull() {
+        final Iterator<Object> it = new SkipNullIterator<>(asList(null, null).iterator());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testNonNull() {
+        final Iterator<String> it = new SkipNullIterator<>(asList("foo").iterator());
+        assertTrue(it.hasNext());
+        assertEquals("foo", it.next());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testMixed() {
+        final Iterator<String> it = new SkipNullIterator<>(asList(null, "foo", null).iterator());
+        assertTrue(it.hasNext());
+        assertEquals("foo", it.next());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testMixed2() {
+        final Iterator<String> oriIt = asList("a", "b", null, "c").iterator();
+        Iterator<String> it = new SkipNullIterator<>(oriIt);
+        assertTrue(it.hasNext());
+        assertEquals("a", it.next());
+        assertTrue(it.hasNext());
+        assertEquals("b", it.next());
+        assertTrue(it.hasNext());
+        assertEquals("c", it.next());
+        assertFalse(it.hasNext());
+        assertThrows(NoSuchElementException.class, it::next);
+    }
+
+    @Test
+    public void testDontCallInCtor() {
+        final Iterator<String> dontCallNext = new Iterator<>() {
+            @Override
+            public boolean hasNext() {
+                throw new RuntimeException();
+            }
+
+            @Override
+            public String next() {
+                throw new RuntimeException();
+            }
+        };
+
+        new SkipNullIterator<>(dontCallNext);
+    }
+
+    @Test
+    public void testSkipNullIteratorInfinity() {
+        final Iterator<String> oriIt = new Iterator<>() {
+            @Override
+            public boolean hasNext() {
+                return true;
+            }
+
+            @Override
+            public String next() {
+                return "infinity";
+            }
+        };
+
+        final Iterator<String> it = new SkipNullIterator<>(oriIt);
+        for (int i = 0; i < 1000; i++) {
+            assertTrue(it.hasNext());
+            assertEquals("infinity", it.next());
+        }
+    }
+
+    @Test
+    public void testPathological() {
+        final Iterator<String> oriIt = new Iterator<>() {
+            private int ctr;
+
+            @Override
+            public boolean hasNext() {
+                return true;
+            }
+
+            @Override
+            public String next() {
+                return ctr++ > 100000 ? "infinity" : null;
+            }
+        };
+
+        final Iterator<String> it = new SkipNullIterator<>(oriIt);
+        for (int i = 0; i < 1000; i++) {
+            assertTrue(it.hasNext());
+            assertEquals("infinity", it.next());
+        }
+    }
+}

src/uebung09/chess/Board.java

@@ -1,16 +1,16 @@
 package uebung09.chess;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+
 import uebung09.iterator.Array2dIterator;
 
-public class Board extends Array2dIterator<Piece>{
-    private final Piece[][] field = new Piece[8][8];
-    private final List<Piece> pieces = new ArrayList<>();
 
-    Board(){
-        
-    }
+public class Board implements Iterable<Piece>{
+    private final Piece[][] field = new Piece[8][8];
+    //private final List<Piece> pieces = new ArrayList<>();
+
 
     void add(Piece piece) {
         if (piece.getBoard() != this)
@@ -42,7 +42,7 @@ public class Board extends Array2dIterator<Piece>{
     }
 
     public void check() {
-        for (Piece p1 : pieces) {
+        for (Piece p1 : iterator()) {
             System.out.println(p1.toString());
             for (Piece p2 : pieces)
                 if (p1 != p2)
@@ -56,4 +56,11 @@ public class Board extends Array2dIterator<Piece>{
     public String toString() {
         return pieces.toString();
     }
+
+    @Override
+    public Iterator<Piece> iterator() {
+        // TODO Auto-generated method stub
+        return new Array2dIterator<>(null);
+        //throw new UnsupportedOperationException("Unimplemented method 'iterator'");
+    }
 }

src/uebung09/chess/ChessApp.java

@@ -45,6 +45,7 @@ public class ChessApp {
                     case WHITE_QUEEN -> addQueen(Color.white);
                     case BLACK_KNIGHT -> addKnight(Color.black);
                     case WHITE_KNIGHT -> addKnight(Color.white);
+                    case ITERATOR -> board.iterator();
                     default -> System.out.println("Invalid command " + command);
                 }
             }

src/uebung09/iterator/Array2dIterator.java

@@ -4,22 +4,36 @@ import java.util.Iterator;
 
 public class Array2dIterator<T> implements Iterator<T>{
 
+    private T[][] array;
+    private int index = 0;
 
-    public <T> Array2dIterator(T[][] aaray) {
-        
+    public Array2dIterator(T[][] array) {
+        this.array = array;
     }
 
     @Override
     public boolean hasNext() {
-        // TODO Auto-generated method stub
+        for (int i = 0; i < array.length; i++) {
+            for (int j = 0; j < array[i].length; j++) {
+                if (array[i][j+1] != null) {
+                    return true;
+                }
+                if (array[i+1][j] != null) {
+                    return true;
+                }
+            }
+        }
         return false;
     }
 
     @Override
     public T next() {
-        // TODO Auto-generated method stub
+        for (int i = 0; i < array.length; i++) {
+            for (int j = 0; j < array[i].length; j++) {
+                
+            }
+        }
         return null;
     }
 
-
 }