3. Testen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ae6cc996",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Testen mit JUnit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba958ce",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Inhalt dieser Vorlesung ist das Testen von Programmen. In diesem Jupyter-Notebook sind dabei die Beispiele rund um JUnit gesammelt. Die in der Vorlesung verwendete Version ist JUnit 5; das Jupyter Notebook hier verwendet noch JUnit 4 aus technischen Gründen (Unterschiede bestehen im Wesentlichen nur (1) in den Imports, (2) Assertion Messages kommen in JUnit 5 als letzter Parameter, (3) `assertEquals` in JUnit 5 kann mit floating point Zahlen umgehen, und (4) `@Before` heisst `@BeforeEach` in JUnit 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b18f4a37",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Betrachten wir die folgende fehlerhafte Java-Klasse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "050cbaef",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Maximum {\n",
    "  public int get(int x, int y) {\n",
    "    if (x > y) {\n",
    "      return x;\n",
    "    } else {\n",
    "      return x; // Bug!\n",
    "    }\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ddb063d",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wie im Code markiert ist, enthält diese Klasse einen Bug in der `get` Methode. Diese funktioniert korrekt, solange das erste Argument den größeren Wert enthält:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5102432c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Maximum max = new Maximum();\n",
    "max.get(50, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4495035e",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die erwartete Rückgabewert ist 50, und das ist auch was wir bekommen haben -- dieser Fall ist also korrekt implementiert."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aba040d",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Der Fehler tritt auf, wenn das zweite Argument das größere ist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c6d7286",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "max.get(10, 50);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de609e41",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "An dieser Stelle würden wir auch den Rückgabewert 50 erwarten, haben aber 10 erhalten, was klar falsch ist."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f26188d",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Was wir nun in den letzten paar Zeilen gemacht haben ist genau, was man beim Testen macht: Wir haben eine Instanz der Klasse `Maximum` erzeugt, diese mit verschiedenen Parameterwerten aufgerufen, und das Ergebnis überprüft."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a185ed95",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Auswahl der konkreten Aufrufe, Parameter, und die Definition der erwarteten Ausgaben sind Dinge, die wir als Entwickler/Tester immer selber machen müssen. Den Ablauf der einzelnen Schritte können wir allerdings automatisieren mit JUnit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cf1298",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JUnit Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2333d25a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "[JUnit](https://junit.org/junit5/) ist ein Framework mit dem automatisierte Tests für Java Code erstellt und ausgeführt werden können. Die aktuelle Version von JUnit ist 5, in diesem Jupyter Notebook verwende ich allerdings JUnit 4, da sich damit aus dem Notebook heraus leichter die Tests ausführen lassen. Bis auf die Paketnamen bei den Imports ändert sich an den Beispielen aber nichts bei der Verwendung mit JUnit 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3ddfbfe",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Zunächst benötigen wir die Bibliothek selbst als Abhängigkeit. In einem Softwareprojekt würde man diesen Schritt direkt in der Maven oder Gradle Buildkonfiguration vornehmen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce240d4a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%mavenRepo oss-sonatype-snapshots https://oss.sonatype.org/content/repositories/snapshots/\n",
    "%maven junit:junit:4.13.2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55ebb56",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir benötigen 2 zentrale Imports: Zunächst müssen wir JUnit mitteilen, was Tests sind, dazu brauchen wir die Klasse `Test`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2fe96fd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import org.junit.Test;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab59a62",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Um das Ergebnis in einem Test zu überprüfen benötigen wir noch JUnit Assertions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af317a16",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import static org.junit.Assert.*;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e427dc3e",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun implementieren wir unseren ersten Test von oben, d.h. den Aufruf mit 50 und 10. Wir definieren dazu eine neue Klasse `MaximumTest` (wie sie heisst ist uns überlassen). Ein Test ist eine Methode die mit der `@Test` Annotation versehen ist, und keine Parameter übernimmt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "399ae726",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  @Test\n",
    "  public void testMaximum() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    int max = maximum.get(50, 10);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd770609",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Überprüfung des Ergebnisses passiert mit der Methode `assertEquals`, deren erster Parameter der erwartete Wert ist, und der zweite Wert ist der tatsächliche Wert der Ausführung."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "784ec393",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Testausführung passiert normalerweise per Button in der IDE oder Kommando des Build-Tools (Maven/Gradle). Im Jupyter Notebook müssen wir das programmatisch machen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9542d9e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import org.junit.runner.JUnitCore;\n",
    "JUnitCore junit = new JUnitCore();\n",
    "junit.addListener(new  org.junit.internal.TextListener(System.out));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "664cfa93",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b989ad",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Der Output sagt uns, dass ein Test ausgeführt wurde, und dieser hat keinen Fehler gefunden. Erweitern wir also unsere Testklasse mit einem weiteren Test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "859e647d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    int max = maximum.get(50, 10);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    int max = maximum.get(10, 50);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3f271c2",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die beiden Testmethoden haben nun aussagekräftige Namen, mithilfe derer ein Entwickler erkennen kann, was das Ziel des Tests ist. Das ist sehr wichtig sobald ein Projekt mal viele Testklassen und Tests hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c621f08",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6170e613",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "JUnit berichtet nun, dass einer der beiden ausgeführten Tests fehlgeschlagen ist. Die Zeile mit dem `AssertionError` gibt uns auch einen Hinweis auf das Problem: Es wurde `50` erwartet, aber das Ergebnis war `10`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52c0d215",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir mit der Fehlermeldung nicht zufrieden sind, können wir auch eine eigene als ersten Parameter der `assertEquals` einbauen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2e85370",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    int max = maximum.get(50, 10);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    int max = maximum.get(10, 50);\n",
    "    assertEquals(\"If y is larger than x, then y should be returned.\", 50, max);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "011bad31",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc6c43fe",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun beheben wir den Bug."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db7f6998",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Maximum {\n",
    "  public int get(int x, int y) {\n",
    "    if (x > y) {\n",
    "      return x;\n",
    "    } else {\n",
    "      return y; // Fixed\n",
    "    }\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a2784a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ob unser Fix korrekt ist, können wir überprüfen indem wir unsere Tests nochmal ausführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a80f7163",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1be49b25",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Beide unserer Tests erzeugen sich im ersten Schritt eine Instanz der Klasse `Maximum`. Wir können unsere Testklasse vereinfachen, indem wir dieses Objekt als _Test Fixture_ teilen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ef6291d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  private Maximum maximum = new Maximum();\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    int max = maximum.get(50, 10);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    int max = maximum.get(10, 50);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26bd97be",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2463b762",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir wollen, dass unsere Test Fixture vor jedem Test auf besondere Art neu initialisiert wird, können wir das mithilfe der `@BeforeTest` Annotation machen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c15a1ec",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import org.junit.Before;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7831bdd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  private Maximum maximum;\n",
    "  \n",
    "  @Before\n",
    "  public void setUp() {\n",
    "    System.out.println(\"Erzeuge neues Maximum-Objekt\");\n",
    "    maximum = new Maximum();\n",
    "  }\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    int max = maximum.get(50, 10);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    int max = maximum.get(10, 50);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3516a01f",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9337ae6d",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Alle Methoden, die mit `@Before` annotiert sind, werden vor jeder einzelnen Testausführung ausgeführt. Analog dazu gibt es auch `@After`. Methoden, die mit `@BeforeClass` (`@AfterClass`) annotiert sind werden einmal zu Beginn (Ende) der gesamten Ausführung aller Tests ausgeführt. In JUnit 5 sind diese Annotationen umbenannt worden zu `@BeforeEach`/`@AfterEach` und `@BeforeAll`/`@AfterAll`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a6aa8a3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Betrachten wir nun eine Variante unserer `Maximum` Klasse, die statt `int`s mit `double`s arbeitet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "699de638",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Maximum {\n",
    "  public double get(double x, double y) {\n",
    "    if (x > y) {\n",
    "      return x;\n",
    "    } else {\n",
    "      return y;\n",
    "    }\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e983cbe",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir aktualisieren auch unsere Testklasse um mit der geänderten Signatur umzugehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4ab613b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  private Maximum maximum = new Maximum();\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    double max = maximum.get(50.0, 10.0);\n",
    "    assertEquals(50.0, max);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    double max = maximum.get(10.0, 50.0);\n",
    "    assertEquals(50, max);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77c5076",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Dann betrachten wir, was bei der Ausführung passiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e832f3b",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf1d4bc",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "JUnit schimpft darüber, dass wir Fliesskommazahlen mit `assertEquals` vergleichen. Der Grund ist, dass Fliesskommaberechnungen aufgrund von Rundungsfehlern so gut wie nie exakt gleich sind. JUnit bietet für den Vergleich von Fliesskommazahlen eigene Assertions, bei denen man ein Epsilon für die Genauigkeit des Vergleichs angeben kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72b585df",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  private Maximum maximum = new Maximum();\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumFirst() {\n",
    "    double max = maximum.get(50.0, 10.0);\n",
    "    assertEquals(50.0, max, 0.001);\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    double max = maximum.get(10.0, 50.0);\n",
    "    assertEquals(50, max, 0.001);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b572c5e0",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12515e45",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Als letzter Hinweis sei noch darauf hingewiesen, dass JUnit eine Vielzahl verschiedener Assertions bietet. Beispielsweise kann man den Wahrheitswert beliebiger Bedingungen mit `assertTrue` und `assertFalse` überprüfen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "780b404a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MaximumTest {\n",
    "\n",
    "  @Test\n",
    "  public void testMaximumSecond() {\n",
    "    Maximum maximum = new Maximum();\n",
    "    double max = maximum.get(10.0, 50.0);\n",
    "    assertTrue(max == 50.0);\n",
    "    assertFalse(max == 10.0);\n",
    "  }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3ba325e",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(MaximumTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b9f6304",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Eine Übersicht über vorhandene Assertions gibt es in der [JUnit 4 Dokumentation](https://junit.org/junit4/javadoc/4.8/org/junit/Assert.html) bzw der [JUnit 5 Dokumentation](https://junit.org/junit5/docs/5.8.2/api/org.junit.jupiter.api/org/junit/jupiter/api/Assertions.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1300ad8b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Test-Driven Development"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42f211b9",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Automatisierte Tests haben zwei konträre Anwendungsszenarios: Man erstellt sich Tests auf der Suche nach Fehlern, und behält diese Tests dann um sicherzustellen, dass sich dieser Fehler nicht wieder neu einschleicht; diesen Anwendungsfall nennt man _Regression Testing_. JUnit Tests dienen aber auch dazu beispielhaft zu spezifizieren, was ein Programm können soll. Für diesen Anwendungsfall erstellt man _zuerst_ Tests, und implementiert dann das durch die Tests beschriebene Verhalten. Dies nennt man _Test Driven Development_ (TDD)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e14b1619",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Vorlesungsbeispiel zu TDD hat als Ziel die Erstellung einer Klasse, die überprüft ob zwei Daten übereinstimmen. Es gibt hierbei 2 Features:\n",
    "1. Feature: Exakte Übereinstimmung\n",
    "2. Feature: Wildcard-Matching auf Jahr, Monat, Tag"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36be11a9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Feature 1: Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbcc26e2",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir beginnen mit einem Red-Bar Pattern, welches die API unserer Klasse und einen einfachen Anwendungsfall angibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fd84479",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import java.time.LocalDate;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1937f7d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DatePatternTest {\n",
    "  @Test\n",
    "  public void testMatches() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 9);\n",
    "      assertTrue(pattern.matches(date));\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afaf9a3a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a73e8008",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir den Test das erste Mal ausführen, ist das initiale Problem, dass die Klasse `DatePattern` noch überhaupt nicht existiert. Dies lässt sich aber leicht beheben. Die initiale Implementierung soll dabei aber nur das minimale Verhalten haben, um den Test zu bestehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5549f104",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  public DatePattern(int year, int month, int day) {\n",
    "  \n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return true;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b69d4a79",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f401df",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun verfeinern wir Schrittweise unser Feature mit neuen Szenarien, die noch nicht abgedeckt sind. Beispielsweise sollte der Tag von der `matches` Methode überprüft werden, und `false` zurückgeben, wenn hier keine Übereinstimmung herrscht. Beispielsweise so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc482909",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePatternTest {\n",
    "  @Test\n",
    "  public void testMatches() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 9);\n",
    "      assertTrue(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherDay() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 8);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71a54843",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db3a88c",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun verfeinern wir die Implementierung von `DatePattern` um auch diesen Test zu bestehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d9297a7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  private int day;\n",
    "  \n",
    "  public DatePattern(int year, int month, int day) {\n",
    "      this.day = day;\n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return otherDate.getDayOfMonth() == day;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0881f5d2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf4d6ba3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir können ähnliche Tests auch zur Überprüfung des Monats und des Jahres hinzufügen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "407df8d5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePatternTest {\n",
    "  @Test\n",
    "  public void testMatches() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 9);\n",
    "      assertTrue(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherDay() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 8);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherMonth() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 4, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "\n",
    "  @Test\n",
    "  public void testMatchesOtherYear() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2021, 5, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87bf6f95",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff034da5",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "...und wiederum einfach implementieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a458d88",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  private int year;\n",
    "  private int month;\n",
    "  private int day;\n",
    "  \n",
    "  public DatePattern(int year, int month, int day) {\n",
    "      this.year = year;\n",
    "      this.month = month;\n",
    "      this.day = day;\n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return otherDate.getYear() == year &&\n",
    "           otherDate.getMonthValue() == month &&\n",
    "           otherDate.getDayOfMonth() == day;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b26a7f2",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4424a8b",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir keine weiteren Tests mehr für das aktuelle Feature finden, können wir den Code noch verbessern, und dann mit dem nächsten Feature weitermachen. Nachdem unser Code so einfach ist, gehen wir direkt zum nächsten Feature über."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec13d9d0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Feature 2: Wildcards"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "035a53bf",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir definieren mit unseren Tests, dass eine `0` für die Jahreszahl dazu führen soll, dass Daten mit beliebigen Jahreszahlen gematched werden sollen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb130674",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePatternTest {\n",
    "  @Test\n",
    "  public void testMatches() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 9);\n",
    "      assertTrue(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherDay() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 8);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherMonth() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 4, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "\n",
    "  @Test\n",
    "  public void testMatchesOtherYear() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2021, 5, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testWildcardYear() {\n",
    "      DatePattern pattern = new DatePattern(0, 5, 9);\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 5, 9)));\n",
    "      assertTrue(pattern.matches(LocalDate.of(1234, 5, 9)));\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f3400d6",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe6cd4f",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Implementierung wird wieder verfeinert um diesen Fall abzudecken."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b0ac279",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  private int year;\n",
    "  private int month;\n",
    "  private int day;\n",
    "  \n",
    "  public DatePattern(int year, int month, int day) {\n",
    "      this.year = year;\n",
    "      this.month = month;\n",
    "      this.day = day;\n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return (year == 0 || otherDate.getYear() == year) &&\n",
    "           otherDate.getMonthValue() == month &&\n",
    "           otherDate.getDayOfMonth() == day;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2686eebb",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd086af",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir brauchen ähnliche Tests auch für Monat und Tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39923121",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePatternTest {\n",
    "  @Test\n",
    "  public void testMatches() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 9);\n",
    "      assertTrue(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherDay() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 5, 8);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testMatchesOtherMonth() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2022, 4, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "\n",
    "  @Test\n",
    "  public void testMatchesOtherYear() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 9);\n",
    "      LocalDate date = LocalDate.of(2021, 5, 9);\n",
    "      assertFalse(pattern.matches(date));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testWildcardYear() {\n",
    "      DatePattern pattern = new DatePattern(0, 5, 9);\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 5, 9)));\n",
    "      assertTrue(pattern.matches(LocalDate.of(1234, 5, 9)));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testWildcardMonth() {\n",
    "      DatePattern pattern = new DatePattern(2022, 0, 9);\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 4, 9)));\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 7, 9)));\n",
    "  }\n",
    "  \n",
    "  @Test\n",
    "  public void testWildcardDay() {\n",
    "      DatePattern pattern = new DatePattern(2022, 5, 0);\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 5, 6)));\n",
    "      assertTrue(pattern.matches(LocalDate.of(2022, 5, 10)));\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "149d5440",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbb2254",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "...und entsprechend auch eine verfeinerte Implementierung, die diese beiden Tests erfüllt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f2cae26",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  private int year;\n",
    "  private int month;\n",
    "  private int day;\n",
    "  \n",
    "  public DatePattern(int year, int month, int day) {\n",
    "      this.year = year;\n",
    "      this.month = month;\n",
    "      this.day = day;\n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return (year == 0 || otherDate.getYear() == year) &&\n",
    "           (month == 0 || otherDate.getMonthValue() == month) &&\n",
    "           (day == 0 || otherDate.getDayOfMonth() == day);\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b18218c8",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c1c99b",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Damit ist auch das zweite Feature fertig, aber besonders schön ist der Code nicht geworden. Der nächste Schritt ist nun, den Code zu verbessern ohne dabei die Funktionalität zu verändern -- was wir mithilfe der Tests jederzeit überprüfen können. Das _Refactoring_ ist etwas, mit dem wir uns in der kommenden Vorlesung genauer beschäftigen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb39dd4d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DatePattern {\n",
    "  private int year;\n",
    "  private int month;\n",
    "  private int day;\n",
    "  \n",
    "  public DatePattern(int year, int month, int day) {\n",
    "      this.year = year;\n",
    "      this.month = month;\n",
    "      this.day = day;\n",
    "  }\n",
    "  \n",
    "  private boolean matchesYear(LocalDate otherDate) {\n",
    "    return year == 0 || otherDate.getYear() == year;\n",
    "  }\n",
    "  \n",
    "  private boolean matchesMonth(LocalDate otherDate) {\n",
    "    return month == 0 || otherDate.getMonthValue() == month;\n",
    "  }\n",
    "  \n",
    "  private boolean matchesDay(LocalDate otherDate) {\n",
    "    return day == 0 || otherDate.getDayOfMonth() == day;\n",
    "  }\n",
    "  \n",
    "  public boolean matches(LocalDate otherDate) {\n",
    "    return matchesYear(otherDate) && matchesMonth(otherDate) && matchesDay(otherDate);\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eabbffc2",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "junit.run(DatePatternTest.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3428f8b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Coverage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93dd60b1",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Testüberdeckung (Code Coverage) ist ein hilfreiches Mittel um abzuschätzen, wie gut der Code getestet ist, und um Schwachstellen in den Tests zu erkennen. In der Vorlesung haben Code Coverage anhand des Kontrollflussgraphen theoretisch definiert, in der Praxis implementieren die meisten IDEs und Build-Werkzeuge Approximationen dieser Kriterien. Beispielsweise verwendet Eclipse die Coverageanalyse-Bibliothek Jacoco. Leider eignet sich Jacoco nur begrenzt zur Demonstration in Jupyter. Wir zeigen kurz das Prinzip, aber für eine bessere Demonstration am besten einfach wie in der Vorlesung demonstriert Tests direkt in Eclipse oder IntelliJ mit Coverage ausführen. Angenommen wir testen weiterhin die `Maximum` Klasse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bb2b4d6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Maximum {\n",
    "  public int get(int x, int y) {\n",
    "    if (x > y) {\n",
    "      return x;\n",
    "    } else {\n",
    "      return y;\n",
    "    }\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c9e9ac3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Um Code Coverage zu messen, muss Jacoco den Code mit zusätzlichen Instruktionen instrumentieren, welche protokollieren welche Zeilen ausgeführt wurden. In der IDE ist das ein einfacher Klick, in Jupyter bedarf es leider etwas Boilerplate Code, den wir aber getrost ignorieren können."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b53181a7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%maven org.jacoco:org.jacoco.core:0.8.10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86181371",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "// Imports für die Analyse in Jupyter\n",
    "import org.jacoco.core.instr.Instrumenter;\n",
    "import org.jacoco.core.runtime.IRuntime;\n",
    "import org.jacoco.core.runtime.LoggerRuntime;\n",
    "import org.jacoco.core.runtime.RuntimeData;\n",
    "import java.lang.reflect.Method;\n",
    "import org.jacoco.core.analysis.Analyzer;\n",
    "import org.jacoco.core.analysis.CoverageBuilder;\n",
    "import org.jacoco.core.analysis.IClassCoverage;\n",
    "import org.jacoco.core.analysis.ICounter;\n",
    "import org.jacoco.core.data.ExecutionDataStore;\n",
    "import org.jacoco.core.data.SessionInfoStore;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc152661",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Zunächst wird die instrumentierte Variante der Klasse `Maximum` erstellt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f969d0f5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "final IRuntime runtime = new LoggerRuntime();\n",
    "final Instrumenter instr = new Instrumenter(runtime);\n",
    "final String targetName = Maximum.class.getName();\n",
    "final String resource = \"/\" + Maximum.class.getName().replace('.', '/') + \".class\";\n",
    "\n",
    "InputStream original =  Maximum.class.getResourceAsStream(resource);\n",
    "final byte[] instrumented = instr.instrument(original, targetName);\n",
    "original.close();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebcf04a7",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Byte-Array `instrumented` enthält die rohen Bytes der instrumentierten Klasse. Diese müssen noch geladen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f5b272",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class MemoryClassLoader extends ClassLoader {\n",
    "\n",
    "    private final Map<String, byte[]> definitions = new HashMap<String, byte[]>();\n",
    "\n",
    "    public void addDefinition(final String name, final byte[] bytes) {\n",
    "        definitions.put(name, bytes);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    protected Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException {\n",
    "        final byte[] bytes = definitions.get(name);\n",
    "        if (bytes != null) {\n",
    "            return defineClass(name, bytes, 0, bytes.length);\n",
    "        }\n",
    "        return super.loadClass(name, resolve);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a0834b9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "// In this tutorial we use a special class loader to directly load the\n",
    "// instrumented class definition from a byte[] instances.\n",
    "final MemoryClassLoader memoryClassLoader = new MemoryClassLoader();\n",
    "memoryClassLoader.addDefinition(targetName, instrumented);\n",
    "final Class<?> targetClass = memoryClassLoader.loadClass(targetName);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c612719",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Klasse `targetClass` ist eine modifizierte Variante von `Maximum`, die zusätzliche Instruktionen für Jacoco enthält."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "138dd49b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "// Jacoco initialisieren\n",
    "final RuntimeData data = new RuntimeData();\n",
    "runtime.startup(data);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bc5cd9a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir simulieren nun die Ausführung eines Tests, bei dem der erste Parameter größer als der zweite ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db506afe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "// Entspricht der Ausführung von new Maximum().get(50, 10);\n",
    "\n",
    "Object targetInstance = targetClass.newInstance();\n",
    "Method method = targetClass.getMethod(\"get\", int.class, int.class);\n",
    "method.invoke(targetInstance, 50, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "510672e0",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Danach kommt die Auswertung durch Jacoco (wie gesagt normal automatisch und ohne dass man sich explizit darum kümmern muss)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40c53ce1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "final ExecutionDataStore executionData = new ExecutionDataStore();\n",
    "final SessionInfoStore sessionInfos = new SessionInfoStore();\n",
    "data.collect(executionData, sessionInfos, false);\n",
    "//runtime.shutdown();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a709b033",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "final CoverageBuilder coverageBuilder = new CoverageBuilder();\n",
    "final Analyzer analyzer = new Analyzer(executionData, coverageBuilder);\n",
    "analyzer.analyzeClass(Maximum.class.getResourceAsStream(resource), \"Maximum\");\n",
    "original.close();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bd7affe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "void printCounter(final String unit, final ICounter counter) {\n",
    "    final Integer missed = Integer.valueOf(counter.getMissedCount());\n",
    "    final Integer total = Integer.valueOf(counter.getTotalCount());\n",
    "    System.out.printf(\"%s of %s %s missed%n\", missed, total, unit);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a268c3c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "String getColor(final int status) {\n",
    "    switch (status) {\n",
    "    case ICounter.NOT_COVERED:\n",
    "        return \"red\";\n",
    "    case ICounter.PARTLY_COVERED:\n",
    "        return \"yellow\";\n",
    "    case ICounter.FULLY_COVERED:\n",
    "        return \"green\";\n",
    "    }\n",
    "    return \"\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8135ba9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for (final IClassCoverage cc : coverageBuilder.getClasses()) {\n",
    "    System.out.printf(\"Coverage of class %s%n\", cc.getName());\n",
    "\n",
    "    printCounter(\"instructions\", cc.getInstructionCounter());\n",
    "    printCounter(\"branches\", cc.getBranchCounter());\n",
    "    printCounter(\"lines\", cc.getLineCounter());\n",
    "    printCounter(\"methods\", cc.getMethodCounter());\n",
    "    printCounter(\"complexity\", cc.getComplexityCounter());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08f95462",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Jacoco erzeugt an dieser Stelle einen Bericht der in etwa so aussieht:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2228e0",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "![Jacoco coverage report](img/3/jacoco1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc02472a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Anhand dieser Information können wir erkennen, dass wir noch keinen Test für den Fall haben, dass der zweite Parameter der größere ist. Führen wir den nun auch noch aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65e492c0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "// Test 2\n",
    "method.invoke(targetInstance, 10, 50);\n",
    "\n",
    "// Jacoco abschliessen\n",
    "// final ExecutionDataStore executionData = new ExecutionDataStore();\n",
    "// final SessionInfoStore sessionInfos = new SessionInfoStore();\n",
    "data.collect(executionData, sessionInfos, false);\n",
    "// runtime.shutdown();\n",
    "\n",
    "// Coverageauswertung\n",
    "final CoverageBuilder coverageBuilder = new CoverageBuilder();\n",
    "final Analyzer analyzer = new Analyzer(executionData, coverageBuilder);\n",
    "analyzer.analyzeClass(Maximum.class.getResourceAsStream(resource), \"Maximum\");\n",
    "//original.close();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c3cb924",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "for (final IClassCoverage cc : coverageBuilder.getClasses()) {\n",
    "    System.out.printf(\"Coverage of class %s%n\", cc.getName());\n",
    "\n",
    "    printCounter(\"instructions\", cc.getInstructionCounter());\n",
    "    printCounter(\"branches\", cc.getBranchCounter());\n",
    "    printCounter(\"lines\", cc.getLineCounter());\n",
    "    printCounter(\"methods\", cc.getMethodCounter());\n",
    "    printCounter(\"complexity\", cc.getComplexityCounter());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fadbada",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "![Jacoco coverage report](img/3/jacoco2.png)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "21.0.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}