Junit Test

[blabliblu]

Hi

Ich möchte einen simplen Juni-Test erstellen. Ich möchte das aus dieser Klasse, die Distanz aus 2 Punkten überprüft wird, ob sie richtig oder falsch ist.


Die Klasse:

public Double calculateDistance(ArrayList<Point2D> points) {
        
        Double distance = 0.0;
        Point2D firstPoint;
        Point2D secondPoint;

        for(int i = 1; i < points.size(); i++){
            firstPoint = points.get(i-1);
            secondPoint = points.get(i);

            distance += firstPoint.distance(secondPoint);
        }

        return distance;
    }

Der Junit Test: Bei mir wird aktuell noch einfach (x: 0, y:10) übergeben, da die Rechnung noch nicht übergeben wurde.

@Test
    public void calculateDistance () {


        Point2D test1 = new Point2D(0.0, 10.0);
        Point2D test2 = new Point2D(20.0, 100.0);
        Point2D test3 = new Point2D(15.0, 150.0);



        assertEquals(10.0, test1);
        assertEquals(80, test2);
        assertEquals(135, test3);


    }

Kann mir jemand dabei helfen, dass der Test funktioniert?

 

[LimDul]

Der Test wird (vermutlich) immer false liefern.

Du vergleichst den Wert 10.0 mit dem Objekt test1. Die sind mit ziemlicher Sicherheit nicht gleich. Was genau möchtest du da eigentlich vergleichen?

 

[blabliblu]

Ich möchte schlussendlich vergleichen, ob die 2 gesetzten "points" mit der Distanz übereinstimmen. Wie es in der calculateDistance-Klasse gerechnet wird. Ich versuche zum ersten mal einen Junit-Teset und bin mir überhaupt nicht sicher ob das geht...

 

[temi]

Du kannst nur gleichartige Dinge miteinander vergleichen. Das ist das Äpfel-mit-Birnen-Ding.

Du müsstest also eine Distanz (als double) berechnen (z. B. mit deiner Berechnungs-Methode) und die mit dem erwarteten (double) Wert vergleichen.

 

[LimDul]

Dann vergiss erst mal das "Wort" Unit-Test und schreib ganz normalen Code:

public void test() {
Point2D p1 = new Point2D(...);
Point2D p2 = new Point2D(...);
double distance = ... Distanzberechnungsaufruf
}

Wenn du das hast, fehlt nur noch das assertEquals(erwarteteDistanz, distance) und du bist fertig

 

[blabliblu]

Du kannst nur gleiche Dinge miteinander vergleichen. Das ist das Äpfel-mit-Birnen-Ding.

Du müsstest also eine Distanz (als double) berechnen und die mit dem erwarteten (double) Wert vergleichen.

Aber muss ich die Distanz neu berechnen oder kann ich mir die Werte von der "calculateDistance" Klasse übergeben lassen?

 

[temi]

Aber muss ich die Distanz neu berechnen oder kann ich mir die Werte von der "calculateDistance" Klasse übergeben lassen?

Na, du möchtest ja die "calculateDistance"-Methode testen. Es gibt also festgelegte Punkte, die Methode berechnet etwas daraus und du vergleichst deren Ergebnis mit dem erwartetem Ergebnis. Insofern musst du dir den Wert von der Methode berechnen lassen.

 

[LimDul]

Mal als Beispiel, du hast folgende Methode:

public static int addiere(int x, int y) {
return x + y;
}

Nun möchtest du testen, ob die richtig funktioniert. Das heißt, du überlegst dir, was wären interessante Werte zum testen. Mal als Beispiel "-3 und 6" Du rechnest selber nach, was du als Ergebnis erwarten würdest - 3. Dann schreibst du einen Unit-Test der genau das prüft:

@Test
public void testAddiere() {
int ergebnis = addiere(-3, 6);
assertEquals(3, ergebnis);
}

Das ist die Form, die eigentlch alle Unit-Tests haben. Du weißt was rauskommen müsste, weil du ja die Eingabe eindeutig vorgibst. Und dann vergleichst du, ob der Aufruf das gewünschte Ergebnis gebracht hat.

 

[kneitzel]

Als kleine Ergänzung zu @LimDul:

Ein Test betseht immer aus drei Schritten:
1. Vorbereitung! Der ist im Beispiel in #8 nicht vorhanden, da nicht benötigt. In den Bereich gehört z.B. die Erstellung von Objekten, die man benötigt. Also z.B. die Erstellung von Punkten von denen man die Differenz berechnen will.

2. Aktion! Hier wird die Aktion ausgeführt, die getestet werden sollen. Das ist in dem Beispiel der Aufruf von addiere. (Das ist in dem Beispiel etwas unschön - hier wird entweder eine Methode der Testklasse aufgerufen oder es gibt einen static import. Hier wird in der Regel auf einer Instanz, die in 1. erzeugt wurde, etwas aufgerufen.

3. Assert! Hier wird dann das Ergebnis geprüft.

Diesen Aufbau sollte man haben. Man findet teilweise auch andere Tests, wo dann immer weiter probiert wird:
- Es wird etwas erstellt und gemacht um das dann zu prüfen.
- Auf den Dingen vom vorherigen Schritt wird was anderes gemacht und das dann geprüft.
- Dann wird noch etwas gemacht und das Ergebnis auch geprüft
- ...

Diese Testketten sind aber in der Regel problematisch und sollten wenn möglich vermieden werden.