JUnit-Skript -- unschön?

[klofisch]

Hallo,

ich wüsste gern ob die Testklasse so ok ist. Ich frage weil ja für jeden Testfall setup() alles neuinitialisiert wird.

package calculator;

import junit.framework.TestCase;
import org.junit.After;
//import org.junit.AfterClass;
import org.junit.Before;
//import org.junit.BeforeClass;
import org.junit.Assert.*;
//import org.junit.Test;
import static org.junit.Assert.assertTrue;

public class calculatorTest extends TestCase {

    private int nbErrors = 0;

    public void testAdd1() {
        calculator calculator = new calculator();
        double result = calculator.add(10, 50);
        assertEquals(60, result, 0);
    }

    public void testAdd2() {
        calculator calculator = new calculator();
        double result = calculator.add(57, 35);
        assertEquals(92, result, 0);
    }
    public void testSub1() {
        calculator calculator = new calculator();
        double result = calculator.sub(50, 10);
        assertEquals(40, result, 0);
    }

    public void testSub2() {
        calculator calculator = new calculator();
        double result = calculator.sub(10, 50);
        assertEquals(-40, result, 0);
    }

    public void testMulti1() {
        calculator calculator = new calculator();
        double result = calculator.multi(5, 7);
        assertEquals(35, result, 0); // (Erwartetes Ergebnis, tatsächliches Ergebnis, DELTA (möglicher Abweichungsraum)
        assertTrue(36 == result);// 36 ist ein falsches Ergebnis deshalb wird hier "true" züruckgegeben
        fail("does not compute :-P");
    }

    public void testMulti2() {
        calculator calculator = new calculator();
        double result = calculator.multi(10, 50);
        assertEquals(500, result, 0);
    }

    public void testDiv1() {
        calculator calculator = new calculator();
        double result = calculator.div(6, 3);
        assertEquals(2, result, 0);        
    }

    public void testDiv2() {
        calculator calculator = new calculator();
        double result = calculator.div(81, 9);
        assertEquals(9, result, 0);
    }

    public static void main(String[] args) {
        calculatorTest test = new calculatorTest();
        try {
            test.testAdd1();
            test.testAdd2();
            test.testSub1();
            test.testSub2();
            test.testMulti1();
            test.testMulti2();
            test.testDiv1();
            test.testDiv2();                        
        } catch (Throwable e) {
            test.nbErrors++;
            e.printStackTrace();
        }
        if (test.nbErrors > 0) {
            throw new RuntimeException("There were " + test.nbErrors + " error(s)");
        }
    }

    public calculatorTest() {
    }

//    @BeforeClass
//    public static void setUpClass() throws Exception {
//    }
//
//    @AfterClass
//    public static void tearDownClass() throws Exception {
//    }

    @Before
    @Override
    public void setUp() {
    }

    @After
    @Override
    public void tearDown() {
    }
}

Danke für Tipps und ein frohes Fest.

Gruß
Peter

 

[Guest]

JUnit-Tests haben keine main-Methode. Klassennamen beginnen mit einem Grossbuchstaben und du solltest auch
Negativtests durchführen (z.B. calculator.div(1,0)), um sicherzustellen, dass das ganze nicht aus dem Ruder läuft,
nur weil falsche Parameter übergeben wurden bzw. dass es zu bekannten Fehlern führt.

 

[klofisch]

Ok,....vielen Dank


Frohe Weihnachten
Peter

 

[kama]

Hallo,

public void testMulti1() {
        calculator calculator = new calculator();
        double result = calculator.multi(5, 7);
        assertEquals(35, result, 0); // (Erwartetes Ergebnis, tatsächliches Ergebnis, DELTA (möglicher Abweichungsraum)
        assertTrue(36 == result);// 36 ist ein falsches Ergebnis deshalb wird hier "true" züruckgegeben
        fail("does not compute :-P");
    }

Kann mir mal einer Kurzen Teil erklären ? Hier werden doch double's verglichen, somit sollte hier doch immer ein Epsilon (letzes Argument der assertEquals() Methode) angegeben sein...

MfG
Karl Heinz Marbaise

 

[Gast]

@kama, das seh ich auch so.

Neben den Negativtests ist es auch angebracht Testwerte zu klassifizieren und dann die Grenzen mitzubetrachten.

z.b: Klassen:
negative Zahlen, 0, positive Zahlen.

Daraus folgt:
-unendlich(Double.MAX_VALUE * -1)
-0 (Double.MIN_VALUE * -1)

0

+0 (Double.MIN_VALUE)
+unendlich (Double.MAX_VALUE)

Diese 5 Testwerte dann in allen Kombinationen Testen.
für calculator.multi(double, double) ergeben sich dann also 25 Testfälle.

 

[kama]

Hallo,

@Gast:
das war dann der eine Teil, was mir nicht wirklich an diesem TestCase klar ist, dass hier

assertEquals(35, result, 0); // (Erwartetes Ergebnis, tatsächliches Ergebnis, DELTA (möglicher Abweichungsraum)
        assertTrue(36 == result);// 36 ist ein falsches Ergebnis deshalb wird hier "true" züruckgegeben
        fail("does not compute :-P");

zuerst ein assertEquals(...) gemacht wird, dann ein assertTrue, was meiner Meinung nach immer fehlschlagen muss und zu guter Letzt noch ein "fail()". Hm....
Also was soll der Test jetzt prüfen ?

Mal von dem "Problem" doubles per "==" zu vergleichen einmal abgesehen....

Weiterhin wäre es "sinnvoll", die Instanzbildung (calculator calculator = new calculator(); ) doch in eine setUp() zu legen....

MfG
Karl Heinz Marbaise