@Override
@Test
public void reject() {
Verify.assertContainsAll(this.newWith(1, 2, 3, 4).reject(Predicates.lessThan(3)), 3, 4);
Verify.assertContainsAll(
this.newWith(1, 2, 3, 4).reject(Predicates.lessThan(3), UnifiedSet.newSet()), 3, 4);
}
@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);
}
@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);
}
@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");
}
@Test
public void toMap() {
MutableList<Integer> integers = SingletonListTest.newWith(1);
MutableMap<Integer, Integer> map =
integers.toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru());
Verify.assertContainsAll(map.keySet(), 1);
Verify.assertContainsAll(map.values(), 1);
}
@Test
public void collectIf() {
Verify.assertContainsAll(
SingletonListTest.newWith(1).collectIf(Integer.class::isInstance, String::valueOf), "1");
Verify.assertContainsAll(
SingletonListTest.newWith(1)
.collectIf(Integer.class::isInstance, String::valueOf, FastList.<String>newList()),
"1");
}
@Override
@Test
public void collectWith() {
Function2<Integer, Integer, Integer> addZeroFunction = (each, parameter) -> each + parameter;
Verify.assertContainsAll(
MultiReaderFastList.newListWith(1, 2, 3).collectWith(addZeroFunction, 0), 1, 2, 3);
Verify.assertContainsAll(
MultiReaderFastList.newListWith(1, 2, 3)
.collectWith(addZeroFunction, 0, FastList.newList()),
1,
2,
3);
}
@Test
public void selectWith() {
Verify.assertContainsAll(
SingletonListTest.newWith(1).selectWith(Predicates2.<Integer>lessThan(), 3), 1);
Verify.assertEmpty(
SingletonListTest.newWith(1).selectWith(Predicates2.<Integer>greaterThan(), 3));
}
@Test
public void forEachWithIndex() {
MutableList<Integer> result = Lists.mutable.of();
MutableList<Integer> collection = SingletonListTest.newWith(1);
collection.forEachWithIndex((object, index) -> result.add(object + index));
Verify.assertContainsAll(result, 1);
}
@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 collectOnFromToInterval() {
Interval interval = Interval.oneTo(5);
LazyIterable<String> result = interval.collect(String::valueOf);
Verify.assertIterableSize(5, result);
Verify.assertContainsAll(result, "1", "5");
}
@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);
}
@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");
}
@Override
@Test
public void toSet() {
MutableList<Integer> integers = this.newWith(1, 2, 3, 4);
MutableSet<Integer> set = integers.toSet();
Verify.assertContainsAll(set, 1, 2, 3, 4);
}
@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);
}
@Test
public void rejectWith() {
Verify.assertEmpty(SingletonListTest.newWith(1).rejectWith(Predicates2.<Integer>lessThan(), 3));
Verify.assertContainsAll(
SingletonListTest.newWith(1)
.rejectWith(Predicates2.<Integer>greaterThan(), 3, UnifiedSet.<Integer>newSet()),
1);
}
@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 toList() {
MutableList<Integer> list = SingletonListTest.newWith(1).toList();
list.add(2);
list.add(3);
list.add(4);
Verify.assertContainsAll(list, 1, 2, 3, 4);
}
@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));
}
@Override
@Test
public void addAllIterable() {
super.addAllIterable();
MutableList<Integer> integers = MultiReaderFastList.newList();
Assert.assertTrue(integers.addAllIterable(Lists.fixedSize.of(1, 2, 3, 4)));
Verify.assertContainsAll(integers, 1, 2, 3, 4);
Assert.assertTrue(integers.addAllIterable(FastList.<Integer>newList(4).with(1, 2, 3, 4)));
Verify.assertStartsWith(integers, 1, 2, 3, 4, 1, 2, 3, 4);
Assert.assertTrue(integers.addAllIterable(Sets.fixedSize.of(5)));
Verify.assertStartsWith(integers, 1, 2, 3, 4, 1, 2, 3, 4, 5);
}
@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 testValues() {
Verify.assertContainsAll(this.mutableMap.values(), this.unmodifiableMap.values().toArray());
}
@Test
public void select() {
Verify.assertContainsAll(SingletonListTest.newWith(1).select(Predicates.lessThan(3)), 1);
Verify.assertEmpty(SingletonListTest.newWith(1).select(Predicates.greaterThan(3)));
}
@Test
public void collect() {
Verify.assertContainsAll(SingletonListTest.newWith(1).collect(String::valueOf), "1");
Verify.assertContainsAll(
SingletonListTest.newWith(1).collect(String::valueOf, UnifiedSet.<String>newSet()), "1");
}
@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 toSet() {
MutableList<Integer> integers = SingletonListTest.newWith(1);
MutableSet<Integer> set = integers.toSet();
Verify.assertContainsAll(set, 1);
}