Java Assertions: Prüfen von Annahmen

Einführung

In diesem Lab werden Sie über Assertions in Java lernen. Sie werden erfahren, wie Assertions erstellt werden und wann sie verwendet werden sollen. Assertions werden verwendet, um Annahmen zu testen, die sich auf unseren Code beziehen, und werden hauptsächlich während der Testphase der Software eingesetzt.

Skills Graph

Ein einfaches Assertion erstellen

Erstellen wir ein einfaches Assertion, das testet, ob eine Zahl gerade ist. Wir nehmen an, dass die Zahl gerade ist und schreiben ein Assertion mit einer geraden Zahl. Wir ändern dann die Zahl und führen den Code aus. Wir sollten einen AssertionError erhalten.

public class AssertionsLab {
    public static void main(String[] args) {
        int number = 4;
        assert (number % 2) == 0;
        System.out.println("Number is even");

        // Ändern Sie den Wert der number-Variable in ungerade
        number = 3;
        assert (number % 2) == 0;
        System.out.println("Number is even");
    }
}

Deaktivieren von Assertions

Standardmäßig sind Assertions in Java deaktiviert. Wir können Assertions mit Befehlszeilenoptionen aktivieren.

Lassen Sie uns die Option -ea verwenden, um Assertions zu aktivieren und den Code auszuführen.

java -ea AssertionsLab

Der Code sollte "Number is even" ausgeben, gefolgt von einem AssertionError.

Lassen Sie uns nun die Assertions mit der Option -da deaktivieren und den Code erneut ausführen.

java -da AssertionsLab

Der Code sollte "Number is even" zweimal ausgeben, ohne Ausnahmen zu werfen.

Verwendung von Assertions zum Testen von Eingaben

Assertions können auch verwendet werden, um Eingaben für eine Methode zu testen. Erstellen wir eine divide-Methode, die zwei Parameter annimmt und das Quotienten zurückgibt, nachdem der erste Parameter durch den zweiten Parameter geteilt wurde. Wir nehmen an, dass der zweite Parameter ungleich null ist und erstellen eine Assertion, um dies zu überprüfen.

public class AssertionsLab {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int result = divide(a, b);
        System.out.println("Result: " + result);

        // Ändern Sie den Wert von b in null
        b = 0;
        result = divide(a, b);
        System.out.println("Result: " + result);
    }

    private static int divide(int a, int b) {
        assert b!= 0 : "Cannot divide by zero";
        return a / b;
    }
}

Verwendung von Assertions zum Debuggen und Testen

Wir können Assertions zum Debuggen und Testen verwenden. Nehmen wir an, dass wir ein Programm haben, das eine Datei liest und die erste nicht-null-Zahl aus ihr zurückgibt. Um dieses Programm zu testen, erstellen wir eine Eingabedatei mit drei Zahlen.

echo "0\n3\n0" > input.txt

Schreiben wir unser Programm, das die Datei liest und die erste nicht-null-Zahl aus ihr zurückgibt. Wir erstellen dann eine Assertion, um zu testen, ob das Programm das korrekte Ergebnis zurückgibt.

import java.io.File;
import java.io.FileNotFoundException;
+ import java.util.Scanner;

public class AssertionsLab {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner scanner = new Scanner(new File("input.txt"));
        int number = 0;
        while (scanner.hasNext()) {
            number = scanner.nextInt();
            if (number!= 0) {
                break;
            }
        }
        assert number == 3 : "Incorrect number read from file";
        System.out.println("First non-zero number: " + number);
    }
}

Wann man Assertions nicht verwenden sollte

Assertions eignen sich nicht zur Validierung von Argumenten öffentlicher Methoden. Diese Assertions können während der Laufzeit deaktiviert werden, was zu unerwartetem Verhalten führen kann.

public class AssertionsLab {
    public static void main(String[] args) {
        int negativeNumber = -1;
        printPositiveNumber(negativeNumber);
    }

    public static void printPositiveNumber(int number) {
        assert (number > 0) : "Not a valid positive number";
        System.out.println("Positive number: " + number);
    }
}

Mache Assertions informativ

Wir können informierende Nachrichten zu Assertions hinzufügen, um sie informativer zu machen und bessere Rückmeldungen im Falle eines Fehlers zu liefern. Wir werden nun die Assertion im vorherigen Code ändern, um eine informierende Nachricht hinzuzufügen.

public class AssertionsLab {
    public static void main(String[] args) {
        int number = -1;
        assert (number > 0) : "Negative number found";
        System.out.println("Number is positive: " + number);
    }
}

Die Nachricht "Negative number found" wird angezeigt, wenn der Code ausgeführt wird.

Verhindern, dass Assertions den Code brechen

Der Zweck von Assertions ist im Allgemeinen, Fehler beim Testen von Software zu finden. Wenn die Assertions jedoch selbst den Code brechen, wird es problematisch. Beispielsweise kann ein vorübergehender Netzwerkfehler oder ein Zeitproblem in einem System dazu führen, dass eine Assertion fehlschlägt. Darüber hinaus besteht das Risiko, dass unser System gegen ungültige und bösartige Eingaben ungeschützt bleibt, wenn wir Assertions verwenden, um Eingaben für öffentliche Methoden zu validieren.

Eine Möglichkeit, die negative Auswirkungen von Assertions zu umgehen, besteht darin, sie vorsichtig zu verwenden. Verwenden Sie Assertions nur für Dinge, die in einem gut entworfenen System niemals passieren sollten.

public class AssertionsLab {
    public static void main(String[] args) {
        double result = squareRoot(4);
        System.out.println("Quadratwurzel: " + result);

        double negativeNumber = -4;
        result = squareRoot(negativeNumber);
        System.out.println("Quadratwurzel: " + result);
    }

    public static double squareRoot(double number) {
        assert number >= 0 : "Number should be non-negative";
        return Math.sqrt(number);
    }
}

Vermeiden von Nebeneffekten

Es ist wichtig, Nebeneffekte zu vermeiden, wenn Assertions verwendet werden. Wir sollten vermeiden, Variablen innerhalb von Assertions zu ändern. Stattdessen sollten die Ausdrücke verwendet werden, um problematische Situationen zu erkennen und mehr diagnostische Informationen bereitzustellen.

public class AssertionsLab {
    public static void main(String[] args) {
        int firstNumber = 1;
        int secondNumber = 2;
        assert (firstNumber = secondNumber) == 0 : "Values are not equal";
        System.out.println("Values are equal");
    }
}

Verwendung von Assertions zum Überprüfen von Switch-Anweisungen

Wir können Assertions verwenden, um zu überprüfen, ob alle möglichen Fälle einer Switch-Anweisung abgedeckt sind. Schreiben wir eine Switch-Anweisung, die den Namen eines Tages anhand seiner Nummer zurückgibt. Wir nehmen an, dass die Nummer im Bereich von 0 bis 6 liegt und erstellen eine Assertion, um dies zu überprüfen.

public class AssertionsLab {
    public static void main(String[] args) {
        int dayNumber = 2;
        String day = getDayName(dayNumber);
        System.out.println("Tag: " + day);

        // Setze dayNumber auf eine ungültige Nummer
        dayNumber = 10;
        day = getDayName(dayNumber);
        System.out.println("Tag: " + day);
    }

    public static String getDayName(int dayNumber) {
        String day;
        switch (dayNumber) {
            case 0:
                day = "Sonntag";
                break;
            case 1:
                day = "Montag";
                break;
            case 2:
                day = "Dienstag";
                break;
            case 3:
                day = "Mittwoch";
                break;
            case 4:
                day = "Donnerstag";
                break;
            case 5:
                day = "Freitag";
                break;
            case 6:
                day = "Samstag";
                break;
            default:
                assert false : "Ungültige Tag-Nummer";
        }
        return day;
    }
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Java Assertions-Labor abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.