Whitebox-Übungsaufgabe „Sortierung“: Kontrollflussgraph, McCabe-Zahl und Überdeckung

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Whitebox-Übungsaufgabe
"Sortierung": Kontrollflussgraph, McCabe-Zahl und Überdeckung“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/codecoverage
- https://oer-informatik.de/zyklomatische-komplexitaet
- https://oer-informatik.de/blackboxtests
- Stilbeispiel: https://oer-informatik.de/whitebox-testfall-uebung-sortierung

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Whitebox-Test
- Kontrollflussgraph
- McCabe-Zahl
- Zyklomatische Komplexität
- Anweisungsüberdeckung
- Zweigüberdeckung
- Blackbox-Test
- JaCoCo
- Sortieralgorithmus

Kompetenzstufe: Profilkompetenz (alternativ: Basiskompetenz, Kernkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Hinweis: In dieser Beispiellösung heißt die Methode anders (selectionSort), der Kontrollflussgraph passt aber. Knoten 1 ist die Initialisierung i = 0, Knoten 2 die Bedingung der äußeren Schleife, 3 das i++, 4 die Initialisierung j = i + 1, 5 die Bedingung der inneren Schleife, 6 das j++, 7 die if-Bedingung, 8 der Tausch und 9 das return.

Anhand des Kontrollflussgraphen – am besten selbst nachzeichnen und alle durchlaufenen Anweisungen und Kanten kennzeichnen. Bei [3;2;1] ist der Vergleich sortieren[i] > sortieren[j] in allen drei Durchläufen wahr (es wird jedes Mal getauscht), der false-Ausgang von Knoten 7 wird also nie genommen.

Anweisungsüberdeckung: C_0=\frac{9}{9}=100\,\%

Über Zweige: Die drei Verzweigungen (Knoten 2, 5 und 7) haben 6 Zweige, Zweig 7-6 wird nicht durchlaufen.

Zweigüberdeckung: C_1=\frac{5}{6}\approx 83\,\%

Über Kanten: Von 11 Kanten wird Kante 7-6 nicht durchlaufen.

Kantenüberdeckung: C_1=\frac{10}{11}\approx 91\,\%

Die Testklasse mit dem Testfall aus d) und den Testfällen aus c) kann z. B. so aussehen (die Methode steht in der Klasse App):

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import org.junit.jupiter.api.Test;

public class AppTest {
    @Test
    public void sortiere_321_Test() {
        assertArrayEquals(new int[]{1, 2, 3}, App.sortiere(new int[]{3, 2, 1}));
    }

    @Test
    public void sortiere_unsortiert_Test() {
        assertArrayEquals(new int[]{1, 2, 3}, App.sortiere(new int[]{2, 3, 1}));
    }

    @Test
    public void sortiere_bereitsSortiert_Test() {
        assertArrayEquals(new int[]{3, 4, 5}, App.sortiere(new int[]{3, 4, 5}));
    }

    @Test
    public void sortiere_leer_Test() {
        assertArrayEquals(new int[]{}, App.sortiere(new int[]{}));
    }

    @Test
    public void sortiere_einElement_Test() {
        assertArrayEquals(new int[]{7}, App.sortiere(new int[]{7}));
    }

    @Test
    public void sortiere_null_Test() {
        assertThrows(NullPointerException.class, () -> App.sortiere(null));
    }
}

Mit dem Testfall aus d) allein meldet JaCoCo 100 % der Anweisungen, aber nur 5 von 6 Zweigen: JaCoCo zählt wie wir je zwei Zweige für die beiden Schleifenbedingungen und die if-Verzweigung. Sobald ein Testfall einen Vergleich ohne Tausch enthält (z. B. das bereits sortierte Array aus c)), sind alle 6 Zweige erreicht. Die Komplexität (Spalte „Cxty“) entspricht mit 4 der McCabe-Zahl aus b).