@Override
@Test
public void subList() {
super.subList();
MutableList<String> list = this.newWith("A", "B", "C", "D");
MutableList<String> sublist = list.subList(1, 3);
Verify.assertPostSerializedEqualsAndHashCode(sublist);
Verify.assertSize(2, sublist);
Verify.assertContainsAll(sublist, "B", "C");
sublist.add("X");
Verify.assertSize(3, sublist);
Verify.assertContainsAll(sublist, "B", "C", "X");
Verify.assertSize(5, list);
Verify.assertContainsAll(list, "A", "B", "C", "X", "D");
sublist.remove("X");
Verify.assertContainsAll(sublist, "B", "C");
Verify.assertContainsAll(list, "A", "B", "C", "D");
Assert.assertEquals("C", sublist.set(1, "R"));
Verify.assertContainsAll(sublist, "B", "R");
Verify.assertContainsAll(list, "A", "B", "R", "D");
sublist.addAll(Arrays.asList("W", "G"));
Verify.assertContainsAll(sublist, "B", "R", "W", "G");
Verify.assertContainsAll(list, "A", "B", "R", "W", "G", "D");
sublist.clear();
Verify.assertEmpty(sublist);
Verify.assertContainsAll(list, "A", "D");
}
@Override
@Test
public void retainAllIterable() {
super.retainAllIterable();
MutableList<Integer> objects = this.newWith(1, 2, 3);
objects.retainAllIterable(Lists.fixedSize.of(1, 2));
Verify.assertSize(2, objects);
Verify.assertContainsAll(objects, 1, 2);
MutableList<Integer> objects2 = this.newWith(1, 2, 3);
objects2.retainAllIterable(Lists.fixedSize.of(1));
Verify.assertSize(1, objects2);
Verify.assertContainsAll(objects2, 1);
MutableList<Integer> objects3 = this.newWith(1, 2, 3);
objects3.retainAllIterable(Lists.fixedSize.of(3));
Verify.assertSize(1, objects3);
Verify.assertContainsAll(objects3, 3);
MutableList<Integer> objects4 = this.newWith(1, 2, 3);
objects4.retainAllIterable(Lists.fixedSize.of(2));
Verify.assertSize(1, objects4);
Verify.assertContainsAll(objects4, 2);
MutableList<Integer> objects5 = this.newWith(1, 2, 3);
objects5.retainAllIterable(Lists.fixedSize.of());
Verify.assertEmpty(objects5);
MutableList<Integer> objects6 = this.newWith(1, 2, 3);
objects6.retainAllIterable(Lists.fixedSize.of(1, 2, 3));
Verify.assertSize(3, objects6);
Verify.assertContainsAll(objects6, 1, 2, 3);
}
@Test
public void newListWithCollection() {
Verify.assertEmpty(MultiReaderFastList.newList(Lists.fixedSize.of()));
Verify.assertEmpty(MultiReaderFastList.newList(Sets.fixedSize.of()));
Verify.assertEmpty(MultiReaderFastList.newList(FastList.newList()));
Verify.assertEmpty(MultiReaderFastList.newList(FastList.newList(4)));
MutableList<Integer> setToList =
MultiReaderFastList.newList(UnifiedSet.newSetWith(1, 2, 3, 4, 5));
Verify.assertNotEmpty(setToList);
Verify.assertSize(5, setToList);
Verify.assertContainsAll(setToList, 1, 2, 3, 4, 5);
MutableList<Integer> arrayListToList =
MultiReaderFastList.newList(Lists.fixedSize.of(1, 2, 3, 4, 5));
Verify.assertNotEmpty(arrayListToList);
Verify.assertSize(5, arrayListToList);
Verify.assertStartsWith(arrayListToList, 1, 2, 3, 4, 5);
MutableList<Integer> fastListToList =
MultiReaderFastList.newList(FastList.<Integer>newList().with(1, 2, 3, 4, 5));
Verify.assertNotEmpty(fastListToList);
Verify.assertSize(5, fastListToList);
Verify.assertStartsWith(fastListToList, 1, 2, 3, 4, 5);
}
@Override
@Test
public void removeAllIterable() {
super.removeAllIterable();
MutableList<Integer> objects = MultiReaderFastList.newListWith(1, 2, 3);
objects.removeAllIterable(Lists.fixedSize.of(1, 2));
Verify.assertSize(1, objects);
Verify.assertContains(3, objects);
MutableList<Integer> objects2 = MultiReaderFastList.newListWith(1, 2, 3);
objects2.removeAllIterable(Lists.fixedSize.of(1));
Verify.assertSize(2, objects2);
Verify.assertContainsAll(objects2, 2, 3);
MutableList<Integer> objects3 = MultiReaderFastList.newListWith(1, 2, 3);
objects3.removeAllIterable(Lists.fixedSize.of(3));
Verify.assertSize(2, objects3);
Verify.assertContainsAll(objects3, 1, 2);
MutableList<Integer> objects4 = MultiReaderFastList.newListWith(1, 2, 3);
objects4.removeAllIterable(Lists.fixedSize.of());
Verify.assertSize(3, objects4);
Verify.assertContainsAll(objects4, 1, 2, 3);
MutableList<Integer> objects5 = MultiReaderFastList.newListWith(1, 2, 3);
objects5.removeAllIterable(Lists.fixedSize.of(1, 2, 3));
Verify.assertEmpty(objects5);
MutableList<Integer> objects6 = MultiReaderFastList.newListWith(1, 2, 3);
objects6.removeAllIterable(Lists.fixedSize.of(2));
Verify.assertSize(2, objects6);
Verify.assertContainsAll(objects6, 1, 3);
}
@Test
public void toArray() {
MutableList<Integer> objects = SingletonListTest.newWith(1);
Object[] array = objects.toArray();
Verify.assertSize(1, array);
Integer[] array2 = objects.toArray(new Integer[1]);
Verify.assertSize(1, array2);
}
@Override
@Test
public void selectAndRejectWith() {
MutableList<Integer> list = this.getIntegerList();
Twin<MutableList<Integer>> result =
list.selectAndRejectWith(Predicates2.in(), Lists.fixedSize.of(1));
Verify.assertSize(1, result.getOne());
Verify.assertSize(4, result.getTwo());
}
@Test
public void addAllAtIndexEmpty() {
MutableList<Integer> integers = this.newWith(5);
integers.addAll(0, Lists.fixedSize.of());
Verify.assertSize(1, integers);
Verify.assertStartsWith(integers, 5);
integers.addAll(0, FastList.newList(4));
Verify.assertSize(1, integers);
Verify.assertStartsWith(integers, 5);
integers.addAll(0, Sets.fixedSize.of());
Verify.assertSize(1, integers);
Verify.assertStartsWith(integers, 5);
FastList<String> zeroSizedList = FastList.newList(0);
zeroSizedList.addAll(0, this.newWith("1", "2"));
}
@Test
public void toSet() {
Interval interval = Interval.evensFromTo(0, 10);
MutableSet<Integer> set = interval.toSet();
Verify.assertContainsAll(set, 0, 2, 4, 6, 8, 10);
Verify.assertSize(6, set);
}
@Test
public void toFastList() {
Interval interval = Interval.evensFromTo(0, 10);
FastList<Integer> toList = (FastList<Integer>) interval.toList();
Verify.assertStartsWith(toList, 0, 2, 4, 6, 8, 10);
Verify.assertSize(6, toList);
}
@Test
public void subListOfSubList() {
MutableList<String> list = this.newWith("A", "B", "C", "D");
MutableList<String> sublist = list.subList(0, 3);
MutableList<String> sublist2 = sublist.subList(0, 2);
Verify.assertSize(2, sublist2);
Verify.assertContainsAll(sublist, "A", "B");
sublist2.add("X");
Verify.assertSize(3, sublist2);
Verify.assertStartsWith(sublist2, "A", "B", "X");
Verify.assertContainsAll(sublist, "A", "B", "C", "X");
Assert.assertEquals("X", sublist2.remove(2));
Verify.assertSize(2, sublist2);
Verify.assertContainsNone(sublist, "X");
Verify.assertContainsNone(sublist2, "X");
}
@Test
public void removeUsingPredicate() {
MutableList<Integer> objects = MultiReaderFastList.newListWith(1, 2, 3, null);
Assert.assertTrue(objects.removeIf(Predicates.isNull()));
Verify.assertSize(3, objects);
Verify.assertContainsAll(objects, 1, 2, 3);
}
@Override
@Test
public void select() {
MutableList<Integer> list = this.getIntegerList();
MutableList<Integer> results = list.select(Integer.class::isInstance);
Verify.assertSize(5, results);
}
@Override
@Test
public void selectWith() {
MutableList<Integer> list = this.getIntegerList();
MutableList<Integer> results = list.selectWith(Predicates2.instanceOf(), Integer.class);
Verify.assertSize(5, results);
}
@Test
public void selectAndRejectWith() {
MutableList<Integer> objects = SingletonListTest.newWith(1);
Twin<MutableList<Integer>> result = objects.selectAndRejectWith(Object::equals, 1);
Verify.assertSize(1, result.getOne());
Verify.assertEmpty(result.getTwo());
}
@Override
@Test
public void removeIfWith() {
MutableList<Integer> objects = MultiReaderFastList.newListWith(1, 2, 3, null);
Assert.assertTrue(objects.removeIfWith((each, ignored) -> each == null, null));
Verify.assertSize(3, objects);
Verify.assertContainsAll(objects, 1, 2, 3);
}
@Test
public void serializationOfSublist() {
MutableList<Integer> collection = this.newWith(1, 2, 3, 4, 5);
MutableList<Integer> deserializedCollection =
SerializeTestHelper.serializeDeserialize(collection.subList(0, 2));
Verify.assertSize(2, deserializedCollection);
Verify.assertStartsWith(deserializedCollection, 1, 2);
Assert.assertEquals(collection.subList(0, 2), deserializedCollection);
}
@Test
public void intervalAsReverseArray() {
Integer[] array = Interval.toReverseArray(1, 5);
Verify.assertSize(5, array);
Assert.assertTrue(ArrayIterate.contains(array, 1));
Assert.assertTrue(ArrayIterate.contains(array, 5));
Assert.assertEquals(ArrayIterate.getFirst(array), Integer.valueOf(5));
Assert.assertEquals(ArrayIterate.getLast(array), Integer.valueOf(1));
}
@Test
public void forEachOnFromToByInterval2() {
List<Integer> result = new ArrayList<>();
Interval interval = Interval.fromToBy(5, 1, -2);
interval.forEach(CollectionAddProcedure.on(result));
Verify.assertSize(3, result);
Verify.assertContains(1, result);
Verify.assertNotContains(2, result);
Verify.assertContains(5, result);
}
@Test
public void reverseForEachOnFromToInterval() {
List<Integer> result = new ArrayList<>();
Interval interval = Interval.oneTo(5);
interval.reverseForEach(result::add);
Verify.assertSize(5, result);
Verify.assertContains(1, result);
Verify.assertContains(5, result);
Assert.assertEquals(Integer.valueOf(5), Iterate.getFirst(result));
Assert.assertEquals(Integer.valueOf(1), Iterate.getLast(result));
result.clear();
interval.reverseThis().reverseForEach(result::add);
Verify.assertSize(5, result);
Verify.assertContains(1, result);
Verify.assertContains(5, result);
Assert.assertEquals(Integer.valueOf(1), Iterate.getFirst(result));
Assert.assertEquals(Integer.valueOf(5), Iterate.getLast(result));
}
@Override
@Test
public void serialization() {
MutableList<Integer> collection = this.newWith(1, 2, 3, 4, 5);
MutableList<Integer> deserializedCollection =
SerializeTestHelper.serializeDeserialize(collection);
Verify.assertSize(5, deserializedCollection);
Verify.assertStartsWith(deserializedCollection, 1, 2, 3, 4, 5);
Assert.assertEquals(collection, deserializedCollection);
}
@Test
public void testEmptyConstructor() {
MutableSortedBagMultimap<Integer, Integer> map = TreeBagMultimap.newMultimap();
for (int i = 1; i < 6; ++i) {
for (int j = 1; j < i + 1; ++j) {
map.put(i, j);
}
}
Verify.assertSize(5, map.keysView().toList());
for (int i = 1; i < 6; ++i) {
Verify.assertSortedBagsEqual(TreeBag.newBag(Interval.oneTo(i)), map.get(i));
}
}
@Test
public void testComparatorConstructors() {
MutableSortedBagMultimap<Boolean, Integer> revMap =
TreeBagMultimap.newMultimap(Collections.reverseOrder());
for (int i = 1; i < 10; ++i) {
revMap.put(IntegerPredicates.isOdd().accept(i), i);
}
Verify.assertSize(2, revMap.keysView().toList());
Verify.assertSortedBagsEqual(
TreeBag.newBagWith(Collections.reverseOrder(), 9, 7, 5, 3, 1), revMap.get(Boolean.TRUE));
Verify.assertSortedBagsEqual(
TreeBag.newBagWith(Collections.reverseOrder(), 8, 6, 4, 2), revMap.get(Boolean.FALSE));
MutableSortedBagMultimap<Boolean, Integer> revMap2 = TreeBagMultimap.newMultimap(revMap);
Verify.assertMapsEqual(revMap2.toMap(), revMap.toMap());
Verify.assertSortedBagsEqual(
TreeBag.newBagWith(Collections.reverseOrder(), 9, 7, 5, 3, 1), revMap2.get(Boolean.TRUE));
}
@Test
public void setKeyPreservation() {
Key key = new Key("key");
Key duplicateKey1 = new Key("key");
ImmutableSet<Key> set1 = Sets.immutable.of(key, duplicateKey1);
Verify.assertSize(1, set1);
Verify.assertContains(key, set1);
Assert.assertSame(key, set1.getFirst());
Key duplicateKey2 = new Key("key");
ImmutableSet<Key> set2 = Sets.immutable.of(key, duplicateKey1, duplicateKey2);
Verify.assertSize(1, set2);
Verify.assertContains(key, set2);
Assert.assertSame(key, set2.getFirst());
Key duplicateKey3 = new Key("key");
ImmutableSet<Key> set3 = Sets.immutable.of(key, new Key("not a dupe"), duplicateKey3);
Verify.assertSize(2, set3);
Verify.assertContainsAll("immutable set", set3, key, new Key("not a dupe"));
Assert.assertSame(key, set3.detect(key::equals));
Key duplicateKey4 = new Key("key");
ImmutableSet<Key> set4 =
Sets.immutable.of(key, new Key("not a dupe"), duplicateKey3, duplicateKey4);
Verify.assertSize(2, set4);
Verify.assertContainsAll("immutable set", set4, key, new Key("not a dupe"));
Assert.assertSame(key, set4.detect(key::equals));
ImmutableSet<Key> set5 =
Sets.immutable.of(key, new Key("not a dupe"), new Key("me neither"), duplicateKey4);
Verify.assertSize(3, set5);
Verify.assertContainsAll(
"immutable set", set5, key, new Key("not a dupe"), new Key("me neither"));
Assert.assertSame(key, set5.detect(key::equals));
ImmutableSet<Key> set6 = Sets.immutable.of(key, duplicateKey2, duplicateKey3, duplicateKey4);
Verify.assertSize(1, set6);
Verify.assertContains(key, set6);
Assert.assertSame(key, set6.detect(key::equals));
}
@Test
public void newSetWith() {
Assert.assertSame(Sets.immutable.of(), Sets.immutable.of(Sets.immutable.of().toArray()));
Verify.assertSize(1, Sets.immutable.of(1).castToSet());
Verify.assertSize(1, Sets.immutable.of(1, 1).castToSet());
Verify.assertSize(1, Sets.immutable.of(1, 1, 1).castToSet());
Verify.assertSize(1, Sets.immutable.of(1, 1, 1, 1).castToSet());
Verify.assertSize(1, Sets.immutable.of(1, 1, 1, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 1, 1, 2).castToSet());
Verify.assertSize(2, Sets.immutable.of(2, 1, 1, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 2, 1, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 2, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 1, 2, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 1, 2).castToSet());
Verify.assertSize(2, Sets.immutable.of(2, 1, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 2, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 2, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 1, 2).castToSet());
Verify.assertSize(2, Sets.immutable.of(2, 1, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 2, 1).castToSet());
Verify.assertSize(2, Sets.immutable.of(1, 2).castToSet());
Verify.assertSize(3, Sets.immutable.of(1, 2, 3).castToSet());
Verify.assertSize(3, Sets.immutable.of(1, 2, 3, 1).castToSet());
Verify.assertSize(3, Sets.immutable.of(2, 1, 3, 1).castToSet());
Verify.assertSize(3, Sets.immutable.of(2, 3, 1, 1).castToSet());
Verify.assertSize(3, Sets.immutable.of(2, 1, 1, 3).castToSet());
Verify.assertSize(3, Sets.immutable.of(1, 1, 2, 3).castToSet());
Verify.assertSize(4, Sets.immutable.of(1, 2, 3, 4).castToSet());
Verify.assertSize(4, Sets.immutable.of(1, 2, 3, 4, 1).castToSet());
}
@Test
public void intervalToList() {
MutableList<Integer> list = Interval.fromTo(1, 5).toList();
Verify.assertSize(5, list);
Verify.assertContainsAll(list, 1, 2, 3, 4, 5);
}
@Test
public void intervalAsReverseList() {
MutableList<Integer> list = Interval.toReverseList(1, 5);
Verify.assertSize(5, list);
Verify.assertStartsWith(list, 5, 4, 3, 2, 1);
}
@Test
public void intervalToSet() {
MutableSet<Integer> set = Interval.toSet(1, 5);
Verify.assertSize(5, set);
Verify.assertContainsAll(set, 1, 2, 3, 4, 5);
}
@Test
public void testMutableTransparency() {
this.mutableMap.remove(NAP_TIME);
Verify.assertSize(this.mutableMap.size(), this.unmodifiableMap);
}
@Test
public void testSize() {
Verify.assertSize(this.mutableMap.size(), this.unmodifiableMap);
}