@Override @Test public void listIterator() { super.listIterator(); CompositeFastList<String> composite = new CompositeFastList<String>(); FastList<String> firstBit = FastList.newListWith("one", "two"); FastList<String> secondBit = FastList.newListWith("three"); composite.addAll(firstBit); composite.addAll(secondBit); ListIterator<String> listIterator = composite.listIterator(); listIterator.add("four"); Verify.assertSize(4, composite); Assert.assertTrue(listIterator.hasNext()); String element = listIterator.next(); Assert.assertEquals("one", element); String element3 = listIterator.next(); Assert.assertEquals("two", element3); String element2 = listIterator.previous(); Assert.assertEquals("two", element2); String element1 = listIterator.next(); Assert.assertEquals("two", element1); listIterator.remove(); Verify.assertSize(3, composite); }
@Test public void removingFromIteratorIsCool() { CompositeFastList<String> undertest = new CompositeFastList<String>(); undertest.addAll(FastList.newListWith("a")); undertest.addAll(FastList.newListWith("b", "c", "d")); Iterator<String> iterator1 = undertest.iterator(); iterator1.next(); iterator1.next(); iterator1.next(); iterator1.remove(); Assert.assertEquals("d", iterator1.next()); Assert.assertEquals(FastList.newListWith("a", "b", "d"), undertest); Iterator<String> iterator2 = undertest.iterator(); iterator2.next(); iterator2.next(); iterator2.remove(); Assert.assertEquals(FastList.newListWith("a", "d"), undertest); Iterator<String> iterator3 = undertest.iterator(); iterator3.next(); iterator3.remove(); Assert.assertEquals(FastList.newListWith("d"), undertest); iterator3.next(); iterator3.remove(); Assert.assertEquals(FastList.newList(), undertest); }
@Test public void testContainsAll() { MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("3", "B", "3", "B")); Assert.assertTrue(list.containsAll(FastList.newList().with("2", "B"))); }
@Override @Test public void retainAll() { super.retainAll(); MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("3", "B", "3", "B")); list.retainAll(FastList.newList().with("2", "B")); Verify.assertSize(3, list); }
@Override @Test public void clear() { super.clear(); MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("3", "B", "3", "B")); list.clear(); Assert.assertTrue(list.isEmpty()); Assert.assertEquals(0, list.size()); }
@Override @Test public void toArray() { super.toArray(); MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(Lists.mutable.<String>of()); list.addAll(FastList.newListWith("3", "B", "3", "B")); list.addAll(Lists.mutable.<String>of()); Assert.assertArrayEquals(new String[] {"1", "2", "3", "4", "3", "B", "3", "B"}, list.toArray()); }
@Override @Test public void lastIndexOf() { super.lastIndexOf(); MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("3", "B", "3", "B")); Assert.assertEquals(6, list.lastIndexOf("3")); Assert.assertEquals(3, list.lastIndexOf("4")); Assert.assertEquals(-1, list.lastIndexOf("missing")); }
@Override @Test public void collectIf() { Assert.assertEquals( FastList.newListWith("1", "2", "3"), MultiReaderFastList.newListWith(1, 2, 3) .collectIf(Integer.class::isInstance, String::valueOf)); Assert.assertEquals( FastList.newListWith("1", "2", "3"), MultiReaderFastList.newListWith(1, 2, 3) .collectIf(Integer.class::isInstance, String::valueOf, FastList.newList())); }
@Test public void testRemoveWithIndex() { MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("3", "B", "3", "B")); Assert.assertEquals("1", list.remove(0)); Verify.assertSize(7, list); Assert.assertEquals("2", list.getFirst()); Assert.assertEquals("B", list.remove(6)); Verify.assertSize(6, list); Assert.assertEquals("3", list.getLast()); }
@Override @Test public void reverseThis() { super.reverseThis(); CompositeFastList<Integer> composite = new CompositeFastList<Integer>(); composite.addAll(FastList.newListWith(9, 8, 7)); composite.addAll(FastList.newListWith(6, 5, 4)); composite.addAll(FastList.newListWith(3, 2, 1)); CompositeFastList<Integer> reversed = composite.reverseThis(); Assert.assertSame(composite, reversed); Assert.assertEquals(Interval.oneTo(9), reversed); }
@Test public void set_bugFix_off_by_one_error() { CompositeFastList<Integer> compositeList = new CompositeFastList<Integer>(); MutableList<Integer> list1 = FastList.newListWith(1, 2, 3); MutableList<Integer> list2 = FastList.newListWith(4, 5); MutableList<Integer> list3 = FastList.newList(); compositeList.addAll(list1); compositeList.addAll(list2); compositeList.addAll(list3); Assert.assertEquals(Integer.valueOf(4), compositeList.get(3)); Assert.assertEquals(Integer.valueOf(4), compositeList.set(3, 99)); Assert.assertEquals(Integer.valueOf(99), compositeList.get(3)); }
@Override @Test public void set() { super.set(); MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("A", "B", "C", "B")); Assert.assertEquals("1", list.set(0, "NEW")); Verify.assertSize(8, list); Assert.assertEquals("NEW", list.getFirst()); Assert.assertEquals("2", list.get(1)); Assert.assertEquals("B", list.set(7, "END")); Verify.assertSize(8, list); Assert.assertEquals("END", list.getLast()); }
@Override @Test public void collect() { MutableList<Boolean> list = MultiReaderFastList.newListWith(Boolean.TRUE, Boolean.FALSE, null); MutableList<String> newCollection = list.collect(String::valueOf); Assert.assertEquals(FastList.newListWith("true", "false", "null"), newCollection); }
@Test public void withWritelockAndDelegate() { MultiReaderFastList<Integer> list = MultiReaderFastList.newList(2); AtomicReference<MutableList<?>> delegateList = new AtomicReference<>(); AtomicReference<MutableList<?>> subLists = new AtomicReference<>(); AtomicReference<Iterator<?>> iterator = new AtomicReference<>(); AtomicReference<Iterator<?>> listIterator = new AtomicReference<>(); AtomicReference<Iterator<?>> listIteratorWithPosition = new AtomicReference<>(); list.withWriteLockAndDelegate( delegate -> { delegate.add(1); delegate.add(2); delegate.add(3); delegate.add(4); delegateList.set(delegate); subLists.set(delegate.subList(1, 3)); iterator.set(delegate.iterator()); listIterator.set(delegate.listIterator()); listIteratorWithPosition.set(delegate.listIterator(3)); }); Assert.assertEquals(FastList.newListWith(1, 2, 3, 4), list); this.assertIteratorThrows(delegateList.get()); this.assertIteratorThrows(subLists.get()); this.assertIteratorThrows(iterator.get()); this.assertIteratorThrows(listIterator.get()); this.assertIteratorThrows(listIteratorWithPosition.get()); }
@Test public void testAddWithIndex() { MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("A", "B", "C", "B")); list.add(3, "NEW"); Verify.assertSize(9, list); Assert.assertEquals("NEW", list.get(3)); Assert.assertEquals("4", list.get(4)); list.add(0, "START"); Verify.assertSize(10, list); Assert.assertEquals("START", list.getFirst()); list.add(10, "END"); Verify.assertSize(11, list); Assert.assertEquals("END", list.getLast()); }
@Override @Test public void forEach() { MutableList<Integer> result = FastList.newList(); MutableList<Integer> collection = MultiReaderFastList.newListWith(1, 2, 3, 4); collection.forEach(CollectionAddProcedure.on(result)); Assert.assertEquals(FastList.newListWith(1, 2, 3, 4), result); }
@Override @Test public void forEachWith() { MutableList<Integer> result = FastList.newList(); MutableList<Integer> collection = MultiReaderFastList.newListWith(1, 2, 3, 4); collection.forEachWith((argument1, argument2) -> result.add(argument1 + argument2), 0); Assert.assertEquals(FastList.newListWith(1, 2, 3, 4), result); }
@Test public void forEachInBoth() { MutableList<Pair<String, String>> list = MultiReaderFastList.newList(); MutableList<String> list1 = MultiReaderFastList.newListWith("1", "2"); MutableList<String> list2 = MultiReaderFastList.newListWith("a", "b"); ListIterate.forEachInBoth( list1, list2, (argument1, argument2) -> list.add(Tuples.pair(argument1, argument2))); Assert.assertEquals(FastList.newListWith(Tuples.pair("1", "a"), Tuples.pair("2", "b")), list); }
@Test public void testGet() { MutableList<String> list = new CompositeFastList<String>(); list.addAll(FastList.newListWith("1", "2", "3", "4")); list.addAll(FastList.newListWith("A", "B", "C", "B")); list.addAll(FastList.newListWith("Cat", "Dog", "Mouse", "Bird")); Assert.assertEquals("1", list.get(0)); Assert.assertEquals("2", list.get(1)); Assert.assertEquals("A", list.get(4)); Assert.assertEquals("4", list.get(3)); Assert.assertEquals("Cat", list.get(8)); Assert.assertEquals("Bird", list.get(11)); Verify.assertThrows( IndexOutOfBoundsException.class, () -> { list.get(12); }); }
@Test public void testHashCode() { CompositeFastList<String> composite = new CompositeFastList<String>(); MutableList<String> list = FastList.newList(); Verify.assertEqualsAndHashCode(composite, list); MutableList<String> list2 = FastList.newListWith("one", "two", "three"); CompositeFastList<String> composite2 = new CompositeFastList<String>(); MutableList<String> firstBit = FastList.newListWith("one", "two"); MutableList<String> secondBit = FastList.newListWith("three"); composite2.addAll(firstBit); composite2.addAll(secondBit); Verify.assertEqualsAndHashCode(list2, composite2); MutableList<String> list1 = FastList.newListWith("one", null, "three"); CompositeFastList<String> composite1 = new CompositeFastList<String>(); MutableList<String> firstBit1 = FastList.newListWith("one", null); MutableList<String> secondBit1 = FastList.newListWith("three"); composite1.addAll(firstBit1); composite1.addAll(secondBit1); Verify.assertEqualsAndHashCode(list1, composite1); }
@Test public void fastListNewWith() { Assert.assertEquals( FastList.newListWith("Alice", "Bob", "Cooper", "Dio"), MultiReaderFastList.newListWith("Alice", "Bob", "Cooper", "Dio")); }