B
BestGoalkeeper
Gast
@mihe7 hat auch schon so ein Thema gemacht, da dachte ich mache ich auch mal.
Zuerst unsere eigene Liste-Klasse:
Es ist also eine Integer-List. Da ich etwas faul war, hab ich von
Dann unsere Test-Klasse, welche die wichtigen Methoden testen sollte:
Wenn alle Methoden bei euch richtig sind, sollten alle Tests grün werden.
Nachteile:
-
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;
}
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.