JUnit 4: Wie man die eigene Liste testen kann [TDD]

B

BestGoalkeeper

Bekanntes Mitglied
@mihe7 hat auch schon so ein Thema gemacht, da dachte ich mache ich auch mal.

Zuerst unsere eigene Liste-Klasse:
Java:
import java.util.ArrayList;
import java.util.List;

public class MyIntList extends ArrayList<Integer> implements List<Integer> {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
}
Es ist also eine Integer-List. Da ich etwas faul war, hab ich von ArrayList<Integer> abgeleitet und die Methoden nicht selber implementiert - das müsstet ihr natürlich tun.

Dann unsere Test-Klasse, welche die wichtigen Methoden testen sollte:
Java:
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class MyIntListTest {
	private final MyIntList L1 = new MyIntList();

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	public List<Integer> createRandomTestListWithAtLeast4Elements() {
		Random random = new Random();
		List<Integer> l2 = new ArrayList<Integer>();
		for (int i = 0; i < 4; i++) {
			l2.add(random.nextInt(10));
		}
		while (random.nextFloat() <= 0.8706f) {
			l2.add(random.nextInt(10));
		}
		return l2;
	}

	@Test
	public void testSize() {
		assertEquals(L1.size(), 0);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.size(), l2.size());
		L1.clear();
	}

	@Test
	public void testIsEmpty() {
		assertEquals(L1.isEmpty(), true);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.isEmpty(), false);
		L1.clear();
	}

	@Test
	public void testContains() {
		assertEquals(L1.contains(42), false);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.contains(l2.get(1)), true);
		L1.clear();
	}

	@Test
	public void testIterator() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		Iterator<Integer> iterator1 = L1.iterator();
		Iterator<Integer> iterator2 = l2.iterator();
		while (iterator1.hasNext()) {
			assertEquals(iterator2.hasNext(), true);
			assertEquals(iterator1.next(), iterator2.next());
		}
		L1.clear();
	}

	@Test
	public void testToArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		Object[] array1 = L1.toArray();
		Object[] array2 = l2.toArray();
		assertArrayEquals(array1, array2);
		L1.clear();
	}

	@Test
	public void testToArrayTArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		@SuppressWarnings("unused")
		Exception exception = assertThrows(ArrayStoreException.class, () -> L1.toArray(new String[0]));
		Integer[] array1 = L1.toArray(new Integer[0]);
		Integer[] array2 = l2.toArray(new Integer[0]);
		assertArrayEquals(array1, array2);
		L1.clear();
	}

	@Test
	public void testAddInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.add(l2.get(0));
		assertEquals(L1.get(0), l2.get(0));
		L1.clear();
	}

	@Test
	public void testRemoveObject() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.remove((Object) l2.get(1)), true);
		L1.clear();
	}

	@Test
	public void testContainsAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.containsAll(l2), true);
		assertEquals(l2.containsAll(L1), true);
		L1.clear();
	}

	@Test
	public void testAddAllCollectionInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll((Collection<Integer>) l2);
		assertEquals(L1.containsAll(l2), true);
		assertEquals(l2.containsAll(L1), true);
		L1.clear();
	}

	@Test
	public void testRemoveAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.removeAll(l2);
		assertEquals(L1.size(), 0);
	}

	@Test
	public void testRetainAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.retainAll(l2);
		assertEquals(L1.size(), l2.size());
		L1.clear();
	}

	@Test
	public void testClear() {
		assertEquals(L1.size(), 0);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertNotEquals(L1.size(), 0);
		L1.clear();
		assertEquals(L1.size(), 0);
	}

	@Test
	public void testGet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		for (int i = 0; i < L1.size(); i++) {
			assertEquals(L1.get(i), l2.get(i));
		}
		L1.clear();
	}

	@Test
	public void testSet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.set(1, 42), l2.get(1));
		assertEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testAddIntInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.add(1, 42);
		assertEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testRemoveInt() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.remove(1), l2.get(1));
		assertNotEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.indexOf(L1.get(1)), l2.indexOf(l2.get(1)));
		assertEquals(L1.indexOf(42), -1);
		L1.clear();
	}

	@Test
	public void testLastIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.lastIndexOf(L1.get(1)), l2.lastIndexOf(l2.get(1)));
		assertEquals(L1.lastIndexOf(42), -1);
		L1.clear();
	}
}

Wenn alle Methoden bei euch richtig sind, sollten alle Tests grün werden. :)

Nachteile:
- addAll sollte früh implementiert werden, da diese Methode in vielen Tests verwendet wird.
 
sascha-sphw

sascha-sphw

Bekanntes Mitglied
@mihe7 hat auch schon so ein Thema gemacht, da dachte ich mache ich auch mal.

Zuerst unsere eigene Liste-Klasse:
Java:
import java.util.ArrayList;
import java.util.List;

public class MyIntList extends ArrayList<Integer> implements List<Integer> {
    /**
     *
     */
    private static final long serialVersionUID = 1L;
}
Es ist also eine Integer-List. Da ich etwas faul war, hab ich von ArrayList<Integer> abgeleitet und die Methoden nicht selber implementiert - das müsstet ihr natürlich tun.

Dann unsere Test-Klasse, welche die wichtigen Methoden testen sollte:
Java:
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class MyIntListTest {
    private final MyIntList L1 = new MyIntList();

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

    public List<Integer> createRandomTestListWithAtLeast4Elements() {
        Random random = new Random();
        List<Integer> l2 = new ArrayList<Integer>();
        for (int i = 0; i < 4; i++) {
            l2.add(random.nextInt(10));
        }
        while (random.nextFloat() <= 0.8706f) {
            l2.add(random.nextInt(10));
        }
        return l2;
    }

    @Test
    public void testSize() {
        assertEquals(L1.size(), 0);
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.size(), l2.size());
        L1.clear();
    }

    @Test
    public void testIsEmpty() {
        assertEquals(L1.isEmpty(), true);
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.isEmpty(), false);
        L1.clear();
    }

    @Test
    public void testContains() {
        assertEquals(L1.contains(42), false);
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.contains(l2.get(1)), true);
        L1.clear();
    }

    @Test
    public void testIterator() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        Iterator<Integer> iterator1 = L1.iterator();
        Iterator<Integer> iterator2 = l2.iterator();
        while (iterator1.hasNext()) {
            assertEquals(iterator2.hasNext(), true);
            assertEquals(iterator1.next(), iterator2.next());
        }
        L1.clear();
    }

    @Test
    public void testToArray() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        Object[] array1 = L1.toArray();
        Object[] array2 = l2.toArray();
        assertArrayEquals(array1, array2);
        L1.clear();
    }

    @Test
    public void testToArrayTArray() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        @SuppressWarnings("unused")
        Exception exception = assertThrows(ArrayStoreException.class, () -> L1.toArray(new String[0]));
        Integer[] array1 = L1.toArray(new Integer[0]);
        Integer[] array2 = l2.toArray(new Integer[0]);
        assertArrayEquals(array1, array2);
        L1.clear();
    }

    @Test
    public void testAddInteger() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.add(l2.get(0));
        assertEquals(L1.get(0), l2.get(0));
        L1.clear();
    }

    @Test
    public void testRemoveObject() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.remove((Object) l2.get(1)), true);
        L1.clear();
    }

    @Test
    public void testContainsAll() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.containsAll(l2), true);
        assertEquals(l2.containsAll(L1), true);
        L1.clear();
    }

    @Test
    public void testAddAllCollectionInteger() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll((Collection<Integer>) l2);
        assertEquals(L1.containsAll(l2), true);
        assertEquals(l2.containsAll(L1), true);
        L1.clear();
    }

    @Test
    public void testRemoveAll() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        L1.removeAll(l2);
        assertEquals(L1.size(), 0);
    }

    @Test
    public void testRetainAll() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        L1.retainAll(l2);
        assertEquals(L1.size(), l2.size());
        L1.clear();
    }

    @Test
    public void testClear() {
        assertEquals(L1.size(), 0);
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertNotEquals(L1.size(), 0);
        L1.clear();
        assertEquals(L1.size(), 0);
    }

    @Test
    public void testGet() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        for (int i = 0; i < L1.size(); i++) {
            assertEquals(L1.get(i), l2.get(i));
        }
        L1.clear();
    }

    @Test
    public void testSet() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.set(1, 42), l2.get(1));
        assertEquals(L1.get(1), Integer.valueOf(42));
        L1.clear();
    }

    @Test
    public void testAddIntInteger() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        L1.add(1, 42);
        assertEquals(L1.get(1), Integer.valueOf(42));
        L1.clear();
    }

    @Test
    public void testRemoveInt() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.remove(1), l2.get(1));
        assertNotEquals(L1.get(1), Integer.valueOf(42));
        L1.clear();
    }

    @Test
    public void testIndexOf() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.indexOf(L1.get(1)), l2.indexOf(l2.get(1)));
        assertEquals(L1.indexOf(42), -1);
        L1.clear();
    }

    @Test
    public void testLastIndexOf() {
        List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
        L1.addAll(l2);
        assertEquals(L1.lastIndexOf(L1.get(1)), l2.lastIndexOf(l2.get(1)));
        assertEquals(L1.lastIndexOf(42), -1);
        L1.clear();
    }
}

Wenn alle Methoden bei euch richtig sind, sollten alle Tests grün werden. :)

Nachteile:
- addAll sollte früh implementiert werden, da diese Methode in vielen Tests verwendet wird.

Bei @mihe7 s Themen steht ja ein Bedarf dahinter. Bei Deinem kann ich das leider nicht erkennen? Warum sollte man sowas wollen?
Und was das mit TDD zu tun hat kann ich leider auch nicht erkennen.
 
B

BestGoalkeeper

Bekanntes Mitglied
Diese Fragen kommen immer wieder mal. Und TDD gibt dir vor, was du zu tun hast - ist nicht so schwer zu begreifen.
Ach so... kann man sich ein full quote nicht sparen?
 
sascha-sphw

sascha-sphw

Bekanntes Mitglied
Diese Fragen kommen immer wieder mal. Und TDD gibt dir vor, was du zu tun hast - ist nicht so schwer zu begreifen.
Ich sehe aber in Deinem Beispiel nichts das irgendwie erklärt was TDD ist und wie man da ran geht, zumal bei Dir auch die Implementierung als erstes kommt. Ich find es ja nicht schlecht, dass Du etwas vermitteln möchtest, aber dann sollte dazu auch was im Beitrag stehen.

Des weiteren würde ich ein anderes Beispiel dafür nehmen, etwas das ggf. näher an der Realität ist. Ein ArrayList<Integer> über Vererbung zu realisieren, da könnte ja der ein oder andere dann wirklich glauben das man das so macht.

Ach so... kann man sich ein full quote nicht sparen?
Hätte ich nicht müssen, aber Macht der Gewohnheit dann doch einfach nur auf Antworten geklickt.
 
B

BestGoalkeeper

Bekanntes Mitglied
und benutzt die korrekten Begriffe
verwende ich auch.

Also nochmal kurz als Erklärung für die, die TDD noch nicht kennen: Man schreibt zuerst die Tests und anschließend anhand der Tests die Implementierungen. Konkret heißt das, dass eine das Interface List<Integer> implementierende Klasse zu schreiben ist. Wie die Tests formuliert werden können habe ich oben angegeben.

Kannst du sagen, was deiner Ansicht nach falsch ist, oder die Klappe halten? Danke.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Also nochmal kurz als Erklärung für die, die TDD noch nicht kennen: Man schreibt zuerst die Tests und anschließend anhand der Tests die Implementierungen. Konkret heißt das, dass eine das Interface List<Integer> implementierende Klasse zu schreiben ist.
Das ist eine so starke verkürzte Wiedergabe, dass sie kaum noch richtig ist, die relevanten Punkte hat du weggelassen. Du beschreibst „Tests First“, mit Test Driven Development hat das aber nicht wirklich was zu tun.


Kannst du sagen, was deiner Ansicht nach falsch ist, oder die Klappe halten? Danke.
Ich sagte schlecht, nicht falsch ;)

Fängt schon an mit dem extends ArrayList, und der Kommentar dazu macht es nicht besser, sondern gang im Gegenteil schlimmer.

Dann die TestKlasse:
  • die Namen sind schlecht
  • L1 folgt nicht den Konventionen
  • Random in Tests benutzten ist schlecht
  • die vier leeren Methoden sind überflüssig
  • die Argumente für assertEquals sind vertauscht
  • die Assertions haben keine Message. Entweder Message oder vernünftige Assertions nutzen
  • die Tests selbst sind zu einem großen sehr schlecht geschrieben, am offensichtlichsten testRetainAll
 
L

LimDul

Top Contributor
Dann mach ich mir mal den Spaß ein Review auf den Test-Code:

Java:
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class MyIntListTest {
// Umbennen, weder sprechend, außerdem widerspricht es den Code-Conventions
	private final MyIntList L1 = new MyIntList();

// Methode ist überflüssig
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

// Methode ist überflüssig
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

// Methode ist überflüssig
	@Before
	public void setUp() throws Exception {
	}

// Methode ist überflüssig
	@After
	public void tearDown() throws Exception {
	}

// Warum public?
	public List<Integer> createRandomTestListWithAtLeast4Elements() {
// Random will man nicht im Test haben
		Random random = new Random();
		List<Integer> l2 = new ArrayList<Integer>();
		for (int i = 0; i < 4; i++) {
			l2.add(random.nextInt(10));
		}
// Was macht das?
		while (random.nextFloat() <= 0.8706f) {
			l2.add(random.nextInt(10));
		}
		return l2;
	}

	@Test
	public void testSize() {
		assertEquals(L1.size(), 0);
// Random Liste ist ganz schlecht, im Fehlerfall kann man es nicht nachvollziehen
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.size(), l2.size());
// Clear ist überflüssig
		L1.clear(); 
	}

	@Test
	public void testIsEmpty() {
		assertEquals(L1.isEmpty(), true);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.isEmpty(), false);
		L1.clear();
	}

	@Test
	public void testContains() {
		assertEquals(L1.contains(42), false);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
// Absolut nicht nachvollziehbar im Fehlerfall
		assertEquals(L1.contains(l2.get(1)), true);
		L1.clear();
	}

	@Test
	public void testIterator() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		Iterator<Integer> iterator1 = L1.iterator();
		Iterator<Integer> iterator2 = l2.iterator();
		while (iterator1.hasNext()) {
			assertEquals(iterator2.hasNext(), true);
			assertEquals(iterator1.next(), iterator2.next());
		}
		L1.clear();
	}

	@Test
	public void testToArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		Object[] array1 = L1.toArray();
		Object[] array2 = l2.toArray();
		assertArrayEquals(array1, array2);
		L1.clear();
	}

	@Test
	public void testToArrayTArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		@SuppressWarnings("unused")
		Exception exception = assertThrows(ArrayStoreException.class, () -> L1.toArray(new String[0]));
		Integer[] array1 = L1.toArray(new Integer[0]);
		Integer[] array2 = l2.toArray(new Integer[0]);
		assertArrayEquals(array1, array2);
		L1.clear();
	}

	@Test
	public void testAddInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.add(l2.get(0));
		assertEquals(L1.get(0), l2.get(0));
		L1.clear();
	}

	@Test
	public void testRemoveObject() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.remove((Object) l2.get(1)), true);
		L1.clear();
	}

	@Test
	public void testContainsAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.containsAll(l2), true);
		assertEquals(l2.containsAll(L1), true);
		L1.clear();
	}

	@Test
	public void testAddAllCollectionInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll((Collection<Integer>) l2);
		assertEquals(L1.containsAll(l2), true);
		assertEquals(l2.containsAll(L1), true);
		L1.clear();
	}

	@Test
	public void testRemoveAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.removeAll(l2);
		assertEquals(L1.size(), 0);
	}

	@Test
	public void testRetainAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.retainAll(l2);
		assertEquals(L1.size(), l2.size());
		L1.clear();
	}

	@Test
	public void testClear() {
		assertEquals(L1.size(), 0);
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertNotEquals(L1.size(), 0);
		L1.clear();
		assertEquals(L1.size(), 0);
	}

	@Test
	public void testGet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		for (int i = 0; i < L1.size(); i++) {
			assertEquals(L1.get(i), l2.get(i));
		}
		L1.clear();
	}

	@Test
	public void testSet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.set(1, 42), l2.get(1));
		assertEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testAddIntInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		L1.add(1, 42);
		assertEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testRemoveInt() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.remove(1), l2.get(1));
		assertNotEquals(L1.get(1), Integer.valueOf(42));
		L1.clear();
	}

	@Test
	public void testIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.indexOf(L1.get(1)), l2.indexOf(l2.get(1)));
		assertEquals(L1.indexOf(42), -1);
		L1.clear();
	}

	@Test
	public void testLastIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		L1.addAll(l2);
		assertEquals(L1.lastIndexOf(L1.get(1)), l2.lastIndexOf(l2.get(1)));
		assertEquals(L1.lastIndexOf(42), -1);
		L1.clear();
	}
}
// Fehlende Testfälle sind alle Grenzfälle mit IndexOutOfBoundsExeptions. null als Element
// Anstelle von einer Random Liste als Vergleichsliste eine fest definierte Liste nehmen, in den meisten Tests reicht es auch einzelne Elemente hinzuzufügen anstelle mit einer Vergleichsliste zu arbeiten.
 
B

BestGoalkeeper

Bekanntes Mitglied
Version 2:
Java:
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import org.junit.Test;

public class MyIntListTest {
	private final MyIntList INITIAL_LIST_TO_TEST = new MyIntList();

	private List<Integer> createRandomTestListWithAtLeast4Elements() {
		Random random = new Random(0);
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 4; i++) {
			list.add(random.nextInt(10));
		}
		while (random.nextFloat() <= 0.8706f) {
			list.add(random.nextInt(10));
		}
		return list;
	}

	@Test
	public void testSize() {
		assertEquals(0, INITIAL_LIST_TO_TEST.size());
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(l2.size(), INITIAL_LIST_TO_TEST.size());
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testIsEmpty() {
		assertEquals(true, INITIAL_LIST_TO_TEST.isEmpty());
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(false, INITIAL_LIST_TO_TEST.isEmpty());
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testContains() {
		assertEquals(false, INITIAL_LIST_TO_TEST.contains(42));
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(true, INITIAL_LIST_TO_TEST.contains(l2.get(1)));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testIterator() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		Iterator<Integer> iterator1 = INITIAL_LIST_TO_TEST.iterator();
		Iterator<Integer> iterator2 = l2.iterator();
		while (iterator2.hasNext()) {
			assertEquals(true, iterator1.hasNext());
			assertEquals(iterator2.next(), iterator1.next());
		}
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testToArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		Object[] array1 = INITIAL_LIST_TO_TEST.toArray();
		Object[] array2 = l2.toArray();
		assertArrayEquals(array2, array1);
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testToArrayTArray() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		@SuppressWarnings("unused")
		Exception exception = assertThrows(ArrayStoreException.class,
				() -> INITIAL_LIST_TO_TEST.toArray(new String[0]));
		Integer[] array1 = INITIAL_LIST_TO_TEST.toArray(new Integer[0]);
		Integer[] array2 = l2.toArray(new Integer[0]);
		assertArrayEquals(array2, array1);
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testAddInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.add(l2.get(0));
		assertEquals(l2.get(0), INITIAL_LIST_TO_TEST.get(0));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testRemoveObject() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(true, INITIAL_LIST_TO_TEST.remove((Object) l2.get(1)));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testContainsAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(true, INITIAL_LIST_TO_TEST.containsAll(l2));
		assertEquals(true, l2.containsAll(INITIAL_LIST_TO_TEST));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testAddAllCollectionInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll((Collection<Integer>) l2);
		assertEquals(true, INITIAL_LIST_TO_TEST.containsAll(l2));
		assertEquals(true, l2.containsAll(INITIAL_LIST_TO_TEST));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testRemoveAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		INITIAL_LIST_TO_TEST.removeAll(l2);
		assertEquals(0, INITIAL_LIST_TO_TEST.size());
	}

	@Test
	public void testRetainAll() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		INITIAL_LIST_TO_TEST.retainAll(l2);
		assertEquals(l2.size(), INITIAL_LIST_TO_TEST.size());
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testClear() {
		assertEquals(0, INITIAL_LIST_TO_TEST.size());
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertNotEquals(0, INITIAL_LIST_TO_TEST.size());
		INITIAL_LIST_TO_TEST.clear();
		assertEquals(0, INITIAL_LIST_TO_TEST.size());
	}

	@Test
	public void testGet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		for (int i = 0; i < INITIAL_LIST_TO_TEST.size(); i++) {
			assertEquals(l2.get(i), INITIAL_LIST_TO_TEST.get(i));
		}
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testSet() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(l2.get(1), INITIAL_LIST_TO_TEST.set(1, 42));
		assertEquals(Integer.valueOf(42), INITIAL_LIST_TO_TEST.get(1));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testAddIntInteger() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		INITIAL_LIST_TO_TEST.add(1, 42);
		assertEquals(Integer.valueOf(42), INITIAL_LIST_TO_TEST.get(1));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testRemoveInt() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(l2.get(1), INITIAL_LIST_TO_TEST.remove(1));
		assertNotEquals(Integer.valueOf(42), INITIAL_LIST_TO_TEST.get(1));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(l2.indexOf(l2.get(1)), INITIAL_LIST_TO_TEST.indexOf(INITIAL_LIST_TO_TEST.get(1)));
		assertEquals(-1, INITIAL_LIST_TO_TEST.indexOf(42));
		INITIAL_LIST_TO_TEST.clear();
	}

	@Test
	public void testLastIndexOf() {
		List<Integer> l2 = createRandomTestListWithAtLeast4Elements();
		INITIAL_LIST_TO_TEST.addAll(l2);
		assertEquals(l2.lastIndexOf(l2.get(1)), INITIAL_LIST_TO_TEST.lastIndexOf(INITIAL_LIST_TO_TEST.get(1)));
		assertEquals(-1, INITIAL_LIST_TO_TEST.lastIndexOf(42));
		INITIAL_LIST_TO_TEST.clear();
	}
}
besser?

die Tests selbst sind zu einem großen sehr schlecht geschrieben
Kannst du vielleicht sagen, was genau du damit meinst?
 
W

White_Fox

Top Contributor
Und ich wünsche mir ein Tutorial über Gradle...ich fände es klasse, wenn sich da mal jemand richtig austoben würde. Der Umfang von mihe7s Tutorial und die Erklärtiefe sind da ein guter Maßstab.
 
B

BestGoalkeeper

Bekanntes Mitglied
BTW. Falls euch das mal passieren sollte, dass ihr die Argumente komplett vertauscht habt, könnt ihr in Eclipse mit dem regex
assertEquals\((.*),(.*)\);
suchen - und mit
assertEquals(\2,\1);
ersetzen.
 
B

BestGoalkeeper

Bekanntes Mitglied
Es fügt zu einer Liste mit 4 Zufallszahlen beliebig viele Zufallszahlen hinzu, aber mit dem Erwartungswert von 5 Zufallszahlen. Also wird die Rückgabeliste in den meisten Fällen 4+5=9 Zahlen (von 0 bis 9 Werten) beinhalten.

Da ich den Seed jetzt auf 0 gesetzt habe, wird immer die gleiche Liste erzeugt...
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Kannst du vielleicht sagen, was genau du damit meinst?
einmal ist das eine Zusammenfassung der anderen Punkte. Random sollte ganz raus, stattdessen einfach [1,3,2,4] nutzen und fertig. Dann sollten die Assertions Messages bekommen, mindestens die, bei denen Schleifen benutzt werden, ein „7 ist nicht gleich 4“ hilft einem da nicht weiter. Dann sollte das clear in jedem Test raus, sowas sollte wenn in @AfterEach zu finden sein, ist hier aber überflüssig. Die Liste kann dann auch einfach in der Methode selbst deklariert werden, das ist kein gemeinsamer Zustand.

Und dann ganz konkret zB testRetainAll, wenn retainAll nichts machen würde, würde der Test trotzdem fehlschlagen. Kannst im Test einfach mal die Zeile mit retainAll entfernen, der Test wird trotzdem nicht fehlschlagen.
Dann testIndexOf, durch die verschachtelten Audrücke blickt niemand durch. Nimm einfach eine Feste Liste, dann steht da nur noch sowas wie assertEquals(3, listUnderTest.indexOf(5)).
Oder auch testRemoveInt, wenn remove einfach nur zwei Indizes vertauschen würde, wäre es erfolgreich. Theoretisch könnte remove aktuell die Liste shuffeln, und der Test würde es nicht merken.
Außerdem testest du aktuell nur den „Happy Path“, wenn ich nichts übersehe.



Ein möglicher Weg für ein Refactoring:
  1. die Liste unter Test inlinen und clean entfernen
  2. die zufällige Liste durch ein List.of(1,3,2,4) ersetzen
  3. dann können alle Aufrufe darauf durch die entsprechenden Konstanten ersetzt werden (zB in l2.lastIndexOf(l2.get(1)))
  4. dann alle verschachtelten Aufrufe entfernen, wenn möglich durch Konstanten ersetzen, ansonsten einfach eine Variable dafür definieren
  5. für jeden Test Vor- und Nachbedingungen noch mal gesondert klarmachen, und überprüfen dass der Test auch genau das sicherstellt (zB für die angesprochenen retainAll und remove)
 
mihe7

mihe7

Top Contributor
Ich finde die Idee eines TDD-Tutorials ganz gut, glaube aber, dass da ein Video besser geeignet wäre. Da dürfte sehr viel Text notwendig sein, um die um 180° gedrehte Denkweise auch wirklich deutlich zu machen; glaub ich.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Ich finde die Idee eines TDD-Tutorials ganz gut, glaube aber, dass da ein Video besser geeignet wäre. Da dürfte sehr viel Text notwendig sein, um die um 180° gedrehte Denkweise auch wirklich deutlich zu machen; glaub ich.
Es geht, ich hab mal eine (wenn auch grobe) Einführung in TDD mit FizzBuzz geschrieben, die könnte ich eigentlich mal überarbeiten und hier rein Stellen
 
L

LimDul

Top Contributor
Das würde mich auch mal reizen, darüber zu diskutieren. Ich werde mit TDD auch nicht warm. Ich werfe bei komplexeren Dinge teilweise die API ein paar mal über den Haufen bis ich eine habe, die tragfähig ist. Da jedes mal Tests mitzuschleifen und zu refaktoren fühlt sich nach Overhead an. Ich nehme für mich in Anspruch beim Design der API auf Testfähigkeit zu achten und nehme dann lieber Refaktoring Aufwand in Kauf, die API testfähig zu machen als dauernd die Tests zu refaktoren. Für mich fühlt sich Test-Driven - außer in akademischen oder Mini-Beispielen - nach mehr Overhead als nutzen an.

PS: Bezüglich der Asserts bevorzuge ich Junit 5 + Hamcrest mit asserThat(wert, is(erwartet)). Da finde ich den Test lesbarer als das assertEquals und ich bekomme direkt sinnvolle Fehlertexte generiert. Aber klar, das ist wieder eine Extra-Lib, die man nicht unbedingt sofort einführen will.
 
mrBrown

mrBrown

Super-Moderator
Mitarbeiter
Das würde mich auch mal reizen, darüber zu diskutieren. Ich werde mit TDD auch nicht warm. Ich werfe bei komplexeren Dinge teilweise die API ein paar mal über den Haufen bis ich eine habe, die tragfähig ist. Da jedes mal Tests mitzuschleifen und zu refaktoren fühlt sich nach Overhead an. Ich nehme für mich in Anspruch beim Design der API auf Testfähigkeit zu achten und nehme dann lieber Refaktoring Aufwand in Kauf, die API testfähig zu machen als dauernd die Tests zu refaktoren. Für mich fühlt sich Test-Driven - außer in akademischen oder Mini-Beispielen - nach mehr Overhead als nutzen an.
Zu dieser tragfähigen API kommen ist ja grad das Ziel von TDD, dass man da durchaus mal Dinge ändern muss ist durchaus erwünscht.
Bei dir entsteht die Schittstelle ja sicherlich auch nicht "aus dem Nichts", entweder ist die direkt an den "richtigen" Code angebunden oder du spielst das detailliert genug im Kopf durch – vermuten würde ich da letzteres, sonst hättest du das Problem mit Refactoring ja trotzdem?

PS: Bezüglich der Asserts bevorzuge ich Junit 5 + Hamcrest mit asserThat(wert, is(erwartet)).
Statt Hamcrest bevorzuge ich AssertJ mit asserThat(wert).isEqualTo(erwartet), grad auch wegen der "Discoverability" durch die IDE.
 
mihe7

mihe7

Top Contributor
Es geht, ich hab mal eine (wenn auch grobe) Einführung in TDD mit FizzBuzz geschrieben, die könnte ich eigentlich mal überarbeiten und hier rein Stellen
Reinstellen! Jetzt! :)

Das würde mich auch mal reizen, darüber zu diskutieren.
Unsere Anwendungen sind so langweilig, dass sich da zu großen Teilen überhaupt kein Test rentiert (das meiste ist einfach CRUD -> Getter/Setter/JPA). Ich wüsste gar nicht, was, wie und warum ich da etwas testen sollte.

Allerdings gibt es einige interessantere Klassen, wo etwas Logik drinsteckt. Bei diesen habe ich durchaus auch TDD angewendet und bin zu 100 % davon überzeugt, dass es dort einiges gebracht hat. Auch bin ich immer wieder erstaunt, in welcher Geschwindigkeit und wie stark sich die Denkweise ändert, sobald man mit diesem Ansatz an die Sache herangeht.
 
mihe7

mihe7

Top Contributor
Und ich wünsche mir ein Tutorial über Gradle...ich fände es klasse, wenn sich da mal jemand richtig austoben würde. Der Umfang von mihe7s Tutorial und die Erklärtiefe sind da ein guter Maßstab.
Du musst einfach nur genügend Fragen stellen und ggf. auf idiotische Youtube-Videos verweisen, bis es jemandem zu blöd wird und den Spaß mal zusammenfasst :p

Tatsächlich war das die Intention hinter den beiden Threads. Wenn hier alle drei Wochen jemand mit einem YT-Pong-like-Code (u. ä.) aufschlägt, dann nervt es, immer und immer wieder das gleiche zu schreiben. Außerdem bin ich bzgl. des Videos immer am Lästern, dann muss man auch mal zeigen, dass es auch anders geht :) Hinzu kommt, dass es daneben auch noch Leute gibt, die sagen: hey, ich hab mir Java-Bücher besorgt und den Spaß gelernt, aber irgendwie fehlt der rote Faden, wie man ein Projekt von vorne bis hinten angehen kann. Auch dafür kann der Beitrag IMO bis zu einem gewissen Grad herhalten. Das Spiel selbst ist ja eigentlich Nebensache - dafür bin ich eigentlich gar nicht geeignet, weil ich normalerweise keine Spiele programmiere.

Hinter dem Beitrag über Arrays steckt eine ähnliche Motivation, aber in wesentlich kleinerem Maßstab. Verkettete Listen wären auch noch so ein Thema, wo es regelmäßig Verständnisprobleme gibt.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
N Fehler bei JUnit Test Java Basics - Anfänger-Themen 5
W JUnit Tests Java Basics - Anfänger-Themen 4
hello_autumn Klassen Anzahl sowie die Anzahl der Junit Tests ermitteln? Java Basics - Anfänger-Themen 8
B JUnit / Exceptions/ try-catch Java Basics - Anfänger-Themen 6
L JUnit tests in java Java Basics - Anfänger-Themen 5
N JUnit und private Methoden testen. Java Basics - Anfänger-Themen 9
F JUnit - Was ist mit "side effects" gemeint ? Java Basics - Anfänger-Themen 2
H JUnit in Eclipse: java.lang.NoClassDefFoundError: Java Basics - Anfänger-Themen 9
B JUnit Test erstellen Java Basics - Anfänger-Themen 6
W Problem bei JUnit Test Aufgabe Java Basics - Anfänger-Themen 15
L Junit Testing bei XML? Java Basics - Anfänger-Themen 3
J LocalDateTime testen mit Junit Java Basics - Anfänger-Themen 20
W JUnit Test und HashCode Java Basics - Anfänger-Themen 14
A Objekt in Methode zurückgeben, JUnit zeigt Error Java Basics - Anfänger-Themen 2
A Kfz - Händler Klasse. JUnit-Test gibt noch Fehler an, aber finde Ursache nicht Java Basics - Anfänger-Themen 7
O JUnit - Objektreferenzen Java Basics - Anfänger-Themen 3
G Testen mit JUnit Java Basics - Anfänger-Themen 4
B Palindrom Test mit Junit Java Basics - Anfänger-Themen 23
C JUnit Tests. How to Java Basics - Anfänger-Themen 5
S Junit Test Java Basics - Anfänger-Themen 2
shiroX Klassen Klasse/Methode private final jUnit-Fehler Java Basics - Anfänger-Themen 5
L Junit Tests Java Basics - Anfänger-Themen 10
A IllegalArgumentException in JUnit testen Java Basics - Anfänger-Themen 3
V ToString-Methode mit JUnit testen(BlueJ) Java Basics - Anfänger-Themen 10
shiroX Methoden JUnit-Test einer void-Methode Java Basics - Anfänger-Themen 4
V JUnit Klassen Java Basics - Anfänger-Themen 3
T Junit Mockito: Instanz von inneren erzeugten Objekten Java Basics - Anfänger-Themen 4
S JUnit - Swing- Anwendung wird nicht neu gestartet Java Basics - Anfänger-Themen 0
B Binäre Suche - Junit Test Java Basics - Anfänger-Themen 6
S Kommt es zu Seiteneffekten wenn man waehrend den laufenden JUnit Tests den Code aendert? Java Basics - Anfänger-Themen 2
M JUnit Testmethoden mit mehreren assert Methoden Java Basics - Anfänger-Themen 1
S Double und Gleitkommazahlen mit JUnit testen Java Basics - Anfänger-Themen 7
K JUnit: Objekte von eigenen Klassen vergleichen...geht nicht Java Basics - Anfänger-Themen 5
Z JUnit Exception Java Basics - Anfänger-Themen 2
M Verständnisfrage zu JUnit Tests und private Methoden Java Basics - Anfänger-Themen 3
M Ist die Hamcrest Bibliothek auch schon in Junit 4.11 verfügbar? Java Basics - Anfänger-Themen 1
S Unterschied .jar Datei ausführen und junit Testfall... Java Basics - Anfänger-Themen 3
M Reihenfolge von Testmethoden in JUnit beeinflussen Java Basics - Anfänger-Themen 2
S Separate Funktion für JUnit-Test Java Basics - Anfänger-Themen 3
G JUnit-Tests im Programmdurchlauf starten Java Basics - Anfänger-Themen 4
T Best Practice JUnit: Wie Klassen durch Stubs/Mockups ersetzen Java Basics - Anfänger-Themen 7
T JUnit test failed Java Basics - Anfänger-Themen 3
M Junit Tests durchführen, die eine Verbindung zu einer Daten erfordern Java Basics - Anfänger-Themen 3
T Junit in Eclipse Java Basics - Anfänger-Themen 1
P JUnit bedeutungen Java Basics - Anfänger-Themen 3
R JUnit Test mit einer Dateistruktur als Testparameter Java Basics - Anfänger-Themen 3
shiroX OOP Array kleinste Zahl mit jUnit test Java Basics - Anfänger-Themen 3
S JUnit assertEquals funktioniert nichgt wie es sollte :( Java Basics - Anfänger-Themen 7
V Frage zu JUnit Tests Java Basics - Anfänger-Themen 3
B JUnit für JFileChooser Java Basics - Anfänger-Themen 6
S Code stimmt nicht für vorgegebenen JUnit-Test Java Basics - Anfänger-Themen 2
S File vergleich - Junit Java Basics - Anfänger-Themen 6
T JUnit Java Basics - Anfänger-Themen 18
G Junit Java Basics - Anfänger-Themen 4
X JUnit testing Java Basics - Anfänger-Themen 7
T JUnit Suite frage Java Basics - Anfänger-Themen 6
R JUnit Test mit mehrfach ausgeführt Java Basics - Anfänger-Themen 6
S InvocationTargetException bei JUnit Testlauf Java Basics - Anfänger-Themen 2
B JUnit - Mini-Test Java Basics - Anfänger-Themen 9
T Unterschied zwischen Integrationstest und JUnit test? Java Basics - Anfänger-Themen 12
Y Junit Test - Testwert ändert sich Java Basics - Anfänger-Themen 12
T Junit --Exception testen Java Basics - Anfänger-Themen 15
A JUnit Tests in Jar-Archiv packen Java Basics - Anfänger-Themen 2
G Erste Schritte JUNIT Regressionstests automatisieren Java Basics - Anfänger-Themen 2
M JUnit - nur einzelne Methode testen? Java Basics - Anfänger-Themen 4
M JUnit - nur Failures loggen? Java Basics - Anfänger-Themen 2
S Hilfe zu Java-Programm und JUnit Test!! Java Basics - Anfänger-Themen 5
T JUNit Test IOException Java Basics - Anfänger-Themen 5
R String Replace für JUnit Java Basics - Anfänger-Themen 19
T JUNIT Nullpointerexception Java Basics - Anfänger-Themen 3
M JUNIT tests mit ant script ausführen Java Basics - Anfänger-Themen 4
S [JUnit] eigener Testsuite Runner + Ausgabe Java Basics - Anfänger-Themen 6
S [JUnit] Print Results while running Java Basics - Anfänger-Themen 6
W Mit jUnit Array testen? Java Basics - Anfänger-Themen 5
T Junit Tests Java Basics - Anfänger-Themen 7
I JUnit Datapoints für mehrere Testklassen Java Basics - Anfänger-Themen 4
Spin JUNIT Test Case - Problem bei testen Java Basics - Anfänger-Themen 2
T brauche HILFE beim Junit test:eek: Java Basics - Anfänger-Themen 11
M Junit tests gehen nicht Java Basics - Anfänger-Themen 2
E OOP einfache Array Aufgabe mit jUnit Java Basics - Anfänger-Themen 5
L JUNIT Testing Java Basics - Anfänger-Themen 3
C jUnit: Erfahren, ob der getestete Code eine Exception gehandelt hat Java Basics - Anfänger-Themen 3
timbeau JUnit Test Dauer speichern/loggen Java Basics - Anfänger-Themen 16
turmaline JUnit testen ob keine Exception auftritt Java Basics - Anfänger-Themen 23
D JUnit auf Matrix anwenden Java Basics - Anfänger-Themen 5
W JUnit 4.X und Parameter Java Basics - Anfänger-Themen 4
xehpuk In JUnit über eigenen Thread testen Java Basics - Anfänger-Themen 3
P JUnit - Optimierung der Testklassen Java Basics - Anfänger-Themen 13
S JUnit: Konsole aktualisiert sich nicht Java Basics - Anfänger-Themen 3
G JUnit ist das neue main() Java Basics - Anfänger-Themen 16
A junit test wann verwendet man "was"? Java Basics - Anfänger-Themen 4
J JUnit Test Java Basics - Anfänger-Themen 2
H JUnit Customizing Java Basics - Anfänger-Themen 5
S JUnit Java Basics - Anfänger-Themen 6
M Junit TestCase für Random() Zahlen Java Basics - Anfänger-Themen 6
R Junit - assertEquals Java Basics - Anfänger-Themen 4
N Junit-hilfe !!! Java Basics - Anfänger-Themen 4
F Gleiche JUnit-Tests automatisert mit verschiedenen Methoden ausführen Java Basics - Anfänger-Themen 6
Houly JUnit Test Suite anlegen Java Basics - Anfänger-Themen 6
B OOP Testen - JUnit Java Basics - Anfänger-Themen 30

Ähnliche Java Themen

Anzeige

Neue Themen


Oben