public void testInternalState_CursorNextNextRemoveByIterator() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", c1.next()); c1.remove(); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(false, c1.currentRemovedByAnother); assertEquals(null, c1.current); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }
assertEquals("1",elts[0]); assertEquals("2",elts[1]); assertEquals("3",elts[2]); assertEquals("4",elts[3]); assertEquals("5",elts[4]); assertEquals(5,elts.length); assertEquals("1",elts2[0]); assertEquals("2",elts2[1]); assertEquals("3",elts2[2]); assertEquals("4",elts2[3]); assertEquals("5",elts2[4]); assertEquals(5,elts2.length); assertSame(elts3,list.toArray(elts3)); assertEquals("1",elts3[0]); assertEquals("2",elts3[1]); assertEquals("3",elts3[2]); assertEquals("4",elts3[3]); assertEquals("5",elts3[4]); assertEquals(5,elts3.length); assertTrue(elts4 != elts4b); assertEquals("1",elts4b[0]); assertEquals("2",elts4b[1]); assertEquals("3",elts4b[2]); assertEquals("4",elts4b[3]); assertEquals("5",elts4b[4]); assertEquals(5,elts4b.length);
list.add("5"); Iterator it = list.iterator(); assertTrue(it.hasNext()); assertEquals("1",it.next()); assertTrue(it.hasNext()); assertEquals("2",it.next()); assertTrue(it.hasNext()); assertEquals("3",it.next()); assertTrue(it.hasNext()); assertEquals("4",it.next()); assertTrue(it.hasNext()); assertEquals("5",it.next()); assertTrue(!it.hasNext()); assertTrue(it.hasNext()); assertEquals("1",it.next()); it.remove(); assertEquals("[2, 3, 4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("2",it.next()); it.remove(); assertEquals("[3, 4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("3",it.next()); it.remove(); assertEquals("[4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("4",it.next()); it.remove();
public void testGet() { try { list.get(0); fail("shouldn't get here"); } catch(IndexOutOfBoundsException e) { // expected } assertTrue(list.add("A")); assertEquals("A",list.get(0)); assertTrue(list.add("B")); assertEquals("A",list.get(0)); assertEquals("B",list.get(1)); try { list.get(-1); fail("shouldn't get here"); } catch(IndexOutOfBoundsException e) { // expected } try { list.get(2); fail("shouldn't get here"); } catch(IndexOutOfBoundsException e) { // expected } }
public void testListIteratorAdd() { ListIterator it = list.listIterator(); it.add("1"); assertEquals("[1]",list.toString()); it.add("3"); assertEquals("[1, 3]",list.toString()); it.add("5"); assertEquals("[1, 3, 5]",list.toString()); assertEquals("5",it.previous()); it.add("4"); assertEquals("[1, 3, 4, 5]",list.toString()); assertEquals("4",it.previous()); assertEquals("3",it.previous()); it.add("2"); assertEquals("[1, 2, 3, 4, 5]",list.toString()); }
public void testContains() { assertTrue(!list.contains("A")); assertTrue(list.add("A")); assertTrue(list.contains("A")); assertTrue(list.add("B")); assertTrue(list.contains("A")); assertTrue(list.addFirst("a")); assertTrue(list.contains("A")); assertTrue(list.remove("a")); assertTrue(list.contains("A")); assertTrue(list.remove("A")); assertTrue(!list.contains("A")); }
public static Test suite() { TestSuite suite = new TestSuite(); suite.addTest(TestCursorableLinkedList.suite()); suite.addTest(TestNodeCachingLinkedList.suite()); suite.addTest(TestTreeList.suite()); suite.addTest(TestFixedSizeList.suite()); suite.addTest(TestGrowthList.suite()); suite.addTest(TestPredicatedList.suite()); suite.addTest(TestSetUniqueList.suite()); suite.addTest(TestSynchronizedList.suite()); suite.addTest(TestTransformedList.suite()); suite.addTest(TestTypedList.suite()); suite.addTest(TestUnmodifiableList.suite()); return suite; }
list.add("5"); ListIterator it = list.listIterator(); assertTrue(it.hasNext()); assertTrue(!it.hasPrevious()); assertEquals(-1,it.previousIndex()); assertEquals(0,it.nextIndex()); assertEquals("1",it.next()); assertTrue(it.hasNext()); assertTrue(it.hasPrevious()); assertEquals(0,it.previousIndex()); assertEquals(1,it.nextIndex()); assertEquals("1",it.previous()); assertTrue(it.hasNext()); assertTrue(!it.hasPrevious()); assertEquals(-1,it.previousIndex()); assertEquals(0,it.nextIndex()); assertEquals("1",it.next()); assertTrue(it.hasNext()); assertTrue(it.hasPrevious()); assertEquals(0,it.previousIndex()); assertEquals(1,it.nextIndex()); assertEquals("2",it.next()); assertTrue(it.hasNext()); assertTrue(it.hasPrevious()); assertEquals(1,it.previousIndex()); assertEquals(2,it.nextIndex()); assertEquals("2",it.previous()); assertTrue(it.hasNext()); assertTrue(it.hasPrevious());
try { it.remove(); fail(); } catch(IllegalStateException e) { assertEquals("1",it.next()); assertEquals("2",it.next()); assertEquals("[1, 2, 3, 4, 5]",list.toString()); it.remove(); assertEquals("[1, 3, 4, 5]",list.toString()); assertEquals("3",it.next()); assertEquals("3",it.previous()); assertEquals("1",it.previous()); it.remove(); assertEquals("[3, 4, 5]",list.toString()); assertTrue(!it.hasPrevious()); assertEquals("3",it.next()); it.remove(); assertEquals("[4, 5]",list.toString()); try { it.remove(); assertEquals("4",it.next()); assertEquals("5",it.next()); it.remove(); assertEquals("[4]",list.toString()); assertEquals("4",it.previous()); it.remove(); assertEquals("[]",list.toString());
public void testListIteratorSet() { list.add("1"); list.add("2"); list.add("3"); list.add("4"); list.add("5"); ListIterator it = list.listIterator(); assertEquals("1",it.next()); it.set("a"); assertEquals("a",it.previous()); it.set("A"); assertEquals("A",it.next()); assertEquals("2",it.next()); it.set("B"); assertEquals("3",it.next()); assertEquals("4",it.next()); it.set("D"); assertEquals("5",it.next()); it.set("E"); assertEquals("[A, B, 3, D, E]",list.toString()); }
public void testLongSerialization() throws Exception { // recursive serialization will cause a stack // overflow exception with long lists for(int i=0;i<10000;i++) { list.add(new Integer(i)); } java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream(); java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf); out.writeObject(list); out.flush(); out.close(); java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray()); java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin); Object list2 = in.readObject(); assertTrue(list != list2); assertTrue(list2.equals(list)); assertTrue(list.equals(list2)); }
public void testInternalState_CursorNextRemoveIndex1ByList() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", list.remove(1)); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(false, c1.currentRemovedByAnother); assertEquals("A", c1.current.value); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); c1.remove(); // works ok assertEquals("[C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }
assertEquals("1",it.next()); assertEquals("2",it.next()); assertEquals("[1, 2, 3, 4, 5]",list.toString()); it.remove(); assertEquals("[1, 3, 4, 5]",list.toString()); assertEquals("3",it.next()); assertEquals("3",it.previous()); assertEquals("1",it.previous()); it.remove(); assertEquals("[3, 4, 5]",list.toString()); assertTrue(!it.hasPrevious()); assertEquals("3",it.next()); it.remove(); assertEquals("[4, 5]",list.toString()); try { it.remove(); assertEquals("4",it.next()); assertEquals("5",it.next()); it.remove(); assertEquals("[4]",list.toString()); assertEquals("4",it.previous()); it.remove(); assertEquals("[]",list.toString());
public void testSubList() { list.add("A"); list.add("B"); list.add("C"); list.add("D"); list.add("E"); assertEquals("[A, B, C, D, E]",list.toString()); assertEquals("[A, B, C, D, E]",list.subList(0,5).toString()); assertEquals("[B, C, D, E]",list.subList(1,5).toString()); assertEquals("[C, D, E]",list.subList(2,5).toString()); assertEquals("[D, E]",list.subList(3,5).toString()); assertEquals("[E]",list.subList(4,5).toString()); assertEquals("[]",list.subList(5,5).toString()); }
public void testIsEmpty() { assertTrue(list.isEmpty()); list.add("element"); assertTrue(!list.isEmpty()); list.remove("element"); assertTrue(list.isEmpty()); list.add("element"); assertTrue(!list.isEmpty()); list.clear(); assertTrue(list.isEmpty()); }
public void testInternalState_CursorNextNextRemoveByListSetByIterator() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", c1.next()); list.remove(1); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(null, c1.current); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); try { c1.set("Z"); fail(); } catch (IllegalStateException ex) {} }
public void testAdd() { assertEquals("[]",list.toString()); assertTrue(list.add(new Integer(1))); assertEquals("[1]",list.toString()); assertTrue(list.add(new Integer(2))); assertEquals("[1, 2]",list.toString()); assertTrue(list.add(new Integer(3))); assertEquals("[1, 2, 3]",list.toString()); assertTrue(list.addFirst(new Integer(0))); assertEquals("[0, 1, 2, 3]",list.toString()); assertTrue(list.addLast(new Integer(4))); assertEquals("[0, 1, 2, 3, 4]",list.toString()); list.add(0,new Integer(-2)); assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString()); list.add(1,new Integer(-1)); assertEquals("[-2, -1, 0, 1, 2, 3, 4]",list.toString()); list.add(7,new Integer(5)); assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]",list.toString()); java.util.List list2 = new java.util.LinkedList(); list2.add("A"); list2.add("B"); list2.add("C"); assertTrue(list.addAll(list2)); assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString()); assertTrue(list.addAll(3,list2)); assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString()); }
public void testSubListRemove() { list.add("A"); list.add("B"); list.add("C"); list.add("D"); list.add("E"); List sublist = list.subList(1,4); assertEquals("[B, C, D]",sublist.toString()); assertEquals("[A, B, C, D, E]",list.toString()); sublist.remove("C"); assertEquals("[B, D]",sublist.toString()); assertEquals("[A, B, D, E]",list.toString()); sublist.remove(1); assertEquals("[B]",sublist.toString()); assertEquals("[A, B, E]",list.toString()); sublist.clear(); assertEquals("[]",sublist.toString()); assertEquals("[A, E]",list.toString()); }
public void testContainsAll() { assertTrue(list.containsAll(list)); java.util.List list2 = new java.util.LinkedList(); assertTrue(list.containsAll(list2)); list2.add("A"); assertTrue(!list.containsAll(list2)); list.add("B"); list.add("A"); assertTrue(list.containsAll(list2)); list2.add("B"); assertTrue(list.containsAll(list2)); list2.add("C"); assertTrue(!list.containsAll(list2)); list.add("C"); assertTrue(list.containsAll(list2)); list2.add("C"); assertTrue(list.containsAll(list2)); assertTrue(list.containsAll(list)); }
public void testInternalState_CursorNextNextPreviousRemoveByIterator() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", c1.next()); assertEquals("B", c1.previous()); c1.remove(); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(false, c1.currentRemovedByAnother); assertEquals(null, c1.current); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }