@Test
public void rejectToTarget() {
ImmutableBag<String> strings = this.newBag();
Assert.assertEquals(
strings, strings.reject(Predicates.lessThan("0"), FastList.<String>newList()).toBag());
Verify.assertEmpty(strings.reject(Predicates.greaterThan("0"), FastList.<String>newList()));
}
@Test
public void retainAllFromEntrySet() {
MutableMapIterable<String, Integer> map =
this.newMapWithKeysValues("One", 1, "Two", 2, "Three", 3);
Assert.assertFalse(
map.entrySet()
.retainAll(
FastList.newListWith(
ImmutableEntry.of("One", 1),
ImmutableEntry.of("Two", 2),
ImmutableEntry.of("Three", 3),
ImmutableEntry.of("Four", 4))));
Assert.assertTrue(
map.entrySet()
.retainAll(
FastList.newListWith(
ImmutableEntry.of("One", 1),
ImmutableEntry.of("Three", 3),
ImmutableEntry.of("Four", 4))));
Assert.assertEquals(UnifiedMap.newWithKeysValues("One", 1, "Three", 3), map);
MutableMapIterable<Integer, Integer> integers = this.newMapWithKeysValues(1, 1, 2, 2, 3, 3);
Integer copy = new Integer(1);
Assert.assertTrue(integers.entrySet().retainAll(mList(ImmutableEntry.of(copy, copy))));
Assert.assertEquals(iMap(copy, copy), integers);
Assert.assertNotSame(copy, Iterate.getOnly(integers.entrySet()).getKey());
Assert.assertNotSame(copy, Iterate.getOnly(integers.entrySet()).getValue());
}
@Test
public void keySet_retainAll() {
// a map with a null key
MutableMap<Integer, Integer> map = this.newMapWithKeyValue(null, 0);
MutableList<Object> retained = Lists.mutable.of();
retained.add(null);
Assert.assertFalse(map.keySet().retainAll(retained));
Verify.assertContains(null, map.keySet());
// a map with a chain containing empty slots
MutableMap<Integer, Integer> map2 = this.mapWithCollisionsOfSize(5);
Assert.assertFalse(map2.keySet().retainAll(FastList.<Integer>newListWith(0, 17, 34, 51, 68)));
Verify.assertContainsAll(map2.keySet(), 0, 17, 34, 51, 68);
// a map with no chaining, nothing retained
MutableMap<Integer, String> map3 = this.newMapWithKeyValue(1, "One");
Assert.assertTrue(map3.keySet().retainAll(FastList.<Integer>newListWith(9)));
Verify.assertEmpty(map3);
Set<Integer> keys =
this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four").keySet();
Assert.assertTrue(keys.retainAll(FastList.<Integer>newListWith(1, 2, 3)));
Verify.assertContainsAll(keys, 1, 2, 3);
}
public <V> MutableList<V> collect(BooleanToObjectFunction<? extends V> function) {
FastList<V> target = FastList.newList(this.size);
for (int i = 0; i < this.size; i++) {
target.add(function.valueOf(this.items.get(i)));
}
return target;
}
@Test
public void selectWith() {
Assert.assertEquals(
FastList.newListWith(1, 2),
this.lazyIterable.selectWith(
Predicates2.<Integer>lessThan(), 3, FastList.<Integer>newList()));
}
@Test
public void keySet_containsAll() {
MutableMap<Integer, String> map =
this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four");
Assert.assertFalse(map.keySet().containsAll(FastList.<Integer>newListWith(5)));
Assert.assertTrue(map.keySet().containsAll(FastList.<Integer>newListWith(1, 2, 4)));
}
@Test
public void rejectWith() {
Assert.assertEquals(
FastList.newListWith(3, 4, 5, 6, 7),
this.lazyIterable.rejectWith(
Predicates2.<Integer>lessThan(), 3, FastList.<Integer>newList()));
}
@Override
@Test
public void retainAllFromEntrySet() {
super.retainAllFromEntrySet();
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Assert.assertFalse(
map.entrySet()
.retainAll(
FastList.newList(map.entrySet())
.with(ImmutableEntry.of(COLLISION_10, COLLISION_10))));
Assert.assertTrue(map.entrySet().retainAll(this.mapWithCollisionsOfSize(i - 1).entrySet()));
Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);
}
// simple map, collection to retain contains non-entry element
MutableMap<Integer, String> map4 = this.newMapWithKeysValues(1, "One", 2, "Two");
FastList<Object> toRetain =
FastList.<Object>newListWith(
ImmutableEntry.of(1, "One"), "explosion!", ImmutableEntry.of(2, "Two"));
Assert.assertFalse(map4.entrySet().retainAll(toRetain));
}
@Override
@Test
public void distinct() {
super.distinct();
Assert.assertEquals(
FastList.newListWith(2, 3, 4, 5),
new DropIterable<>(FastList.newListWith(1, 1, 2, 3, 3, 3, 4, 5), 2).distinct().toList());
}
@Test
public void testForEachWithIndexToArrayUsingFastList() {
Integer[] array = new Integer[200];
FastList<Integer> list = (FastList<Integer>) Interval.oneTo(200).toList();
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
ParallelIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 10, 10);
Assert.assertArrayEquals(array, list.toArray(new Integer[] {}));
}
@Test
public void keysAndValues_toString() {
MutableMapIterable<Integer, String> map = this.newMapWithKeysValues(1, "1", 2, "2");
Verify.assertContains(map.keySet().toString(), FastList.newListWith("[1, 2]", "[2, 1]"));
Verify.assertContains(map.values().toString(), FastList.newListWith("[1, 2]", "[2, 1]"));
Verify.assertContains(map.keysView().toString(), FastList.newListWith("[1, 2]", "[2, 1]"));
Verify.assertContains(map.valuesView().toString(), FastList.newListWith("[1, 2]", "[2, 1]"));
}
@Test
public void retainAllFromValues() {
MutableMapIterable<String, Integer> map =
this.newMapWithKeysValues("One", 1, "Two", 2, "Three", 3);
Assert.assertFalse(map.values().retainAll(FastList.newListWith(1, 2, 3, 4)));
Assert.assertTrue(map.values().retainAll(FastList.newListWith(1, 3)));
Assert.assertEquals(UnifiedMap.newWithKeysValues("One", 1, "Three", 3), map);
}
@Test
public void removeAllFromKeySet() {
MutableMapIterable<String, Integer> map =
this.newMapWithKeysValues("One", 1, "Two", 2, "Three", 3);
Assert.assertFalse(map.keySet().removeAll(FastList.newListWith("Four")));
Assert.assertTrue(map.keySet().removeAll(FastList.newListWith("Two", "Four")));
Assert.assertEquals(UnifiedMap.newWithKeysValues("One", 1, "Three", 3), map);
}
@Test
public void toArray() {
Assert.assertArrayEquals(
FastList.newListWith(1, 2).toArray(),
this.lazyIterable.select(Predicates.lessThan(3)).toArray());
Assert.assertArrayEquals(
FastList.newListWith(1, 2).toArray(),
this.lazyIterable.select(Predicates.lessThan(3)).toArray(new Object[2]));
}
@Test
public void updateValue() {
MutableMapIterable<Integer, Integer> map = this.newMap();
Iterate.forEach(
Interval.oneTo(1000), each -> map.updateValue(each % 10, () -> 0, integer -> integer + 1));
Assert.assertEquals(Interval.zeroTo(9).toSet(), map.keySet());
Assert.assertEquals(
FastList.newList(Collections.nCopies(10, 100)), FastList.newList(map.values()));
}
@Test
public void injectInto() {
ImmutableBag<Integer> integers = this.newBag().collect(Integer::valueOf);
Integer result = integers.injectInto(0, AddFunction.INTEGER);
Assert.assertEquals(
FastList.newList(integers).injectInto(0, AddFunction.INTEGER_TO_INT), result.intValue());
String result1 = this.newBag().injectInto("0", String::concat);
Assert.assertEquals(FastList.newList(this.newBag()).injectInto("0", String::concat), result1);
}
@Test
public void collectIfWithTarget() {
Assert.assertEquals(
FastList.newListWith("1", "2", "3"),
this.newWith(1, 2, 3)
.collectIf(
Predicates.instanceOf(Integer.class),
Functions.getToString(),
FastList.<String>newList()));
}
@Test
public void keySetToArray() {
MutableMapIterable<String, Integer> map =
this.newMapWithKeysValues("One", 1, "Two", 2, "Three", 3);
MutableList<String> expected = FastList.newListWith("One", "Two", "Three").toSortedList();
Set<String> keySet = map.keySet();
Assert.assertEquals(expected, FastList.newListWith(keySet.toArray()).toSortedList());
Assert.assertEquals(
expected, FastList.newListWith(keySet.toArray(new String[keySet.size()])).toSortedList());
}
@Test
public void testReject() {
Assert.assertEquals(
ArrayStack.newStackFromTopToBottom("2", "3"),
this.unmodifiableStackString.reject(StringPredicates.contains("1")));
Assert.assertEquals(
FastList.newListWith("2", "3"),
this.unmodifiableStackString.reject(
StringPredicates.contains("1"), FastList.<String>newList()));
}
@Test
public void entrySet_containsAll() {
// simple map, test for non-existent entries
MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 3, "Three");
Set<Map.Entry<Integer, String>> entries = map.entrySet();
Assert.assertFalse(entries.containsAll(FastList.newListWith(ImmutableEntry.of(2, "Two"))));
Assert.assertTrue(
entries.containsAll(
FastList.newListWith(ImmutableEntry.of(1, "One"), ImmutableEntry.of(3, "Three"))));
}
@Test
public void distinct() {
ArrayList<Integer> list = new ArrayList<Integer>();
list.addAll(FastList.newListWith(9, 4, 7, 7, 5, 6, 2, 4));
List<Integer> result = ArrayListIterate.distinct(list);
Verify.assertListsEqual(FastList.newListWith(9, 4, 7, 5, 6, 2), result);
ArrayList<Integer> target = new ArrayList<Integer>();
ArrayListIterate.distinct(list, target);
Verify.assertListsEqual(FastList.newListWith(9, 4, 7, 5, 6, 2), target);
Verify.assertSize(8, list);
}
@Test
public void updateValue_collisions() {
MutableMapIterable<Integer, Integer> map = this.newMap();
MutableList<Integer> list = Interval.oneTo(2000).toList();
Collections.shuffle(list);
Iterate.forEach(list, each -> map.updateValue(each % 1000, () -> 0, integer -> integer + 1));
Assert.assertEquals(Interval.zeroTo(999).toSet(), map.keySet());
Assert.assertEquals(
HashBag.newBag(map.values()).toStringOfItemToCount(),
FastList.newList(Collections.nCopies(1000, 2)),
FastList.newList(map.values()));
}
@Test
public void makeString() {
Assert.assertEquals(
FastList.newList(this.classUnderTest()).toString(),
'[' + this.classUnderTest().makeString() + ']');
Assert.assertEquals(
FastList.newList(this.classUnderTest()).toString(),
'[' + this.classUnderTest().makeString(", ") + ']');
Assert.assertEquals(
FastList.newList(this.classUnderTest()).toString(),
this.classUnderTest().makeString("[", ", ", "]"));
}
@Test
public void collectWith() {
Assert.assertEquals(
FastList.newListWith("1 ", "2 ", "3 ", "4 ", "5 ", "6 ", "7 "),
this.lazyIterable.collectWith(
new Function2<Integer, String, String>() {
public String value(Integer argument1, String argument2) {
return argument1.toString() + argument2;
}
},
" ",
FastList.<String>newList()));
}
@Test
public void groupByEachWithOptimisedList() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.toReverseList(1, 105));
Function<Integer, Iterable<String>> function =
new Function<Integer, Iterable<String>>() {
public Iterable<String> valueOf(Integer object) {
return FastList.newListWith(object.toString(), object.toString() + '*');
}
};
MutableMultimap<String, Integer> target = new FastListMultimap<String, Integer>();
MutableMultimap<String, Integer> result = ArrayListIterate.groupByEach(list, function, target);
Assert.assertEquals(result.get("105"), FastList.newListWith(105));
Assert.assertEquals(result.get("105*"), FastList.newListWith(105));
}
@Test
public void collectWith() {
Function2<String, String, String> function =
new Function2<String, String, String>() {
public String value(String band, String parameter) {
return parameter + band.charAt(0);
}
};
Assert.assertEquals(
FastList.newListWith(">M", ">B", ">E", ">S"),
this.unmodifiableCollection.collectWith(function, ">"));
Assert.assertEquals(
FastList.newListWith("*M", "*B", "*E", "*S"),
this.unmodifiableCollection.collectWith(function, "*", FastList.<String>newList()));
}
@Test
public void appendString() {
Appendable builder1 = new StringBuilder();
this.classUnderTest().appendString(builder1);
Assert.assertEquals(
FastList.newList(this.classUnderTest()).toString(), '[' + builder1.toString() + ']');
Appendable builder2 = new StringBuilder();
this.classUnderTest().appendString(builder2, ", ");
Assert.assertEquals(
FastList.newList(this.classUnderTest()).toString(), '[' + builder2.toString() + ']');
Appendable builder3 = new StringBuilder();
this.classUnderTest().appendString(builder3, "[", ", ", "]");
Assert.assertEquals(FastList.newList(this.classUnderTest()).toString(), builder3.toString());
}
@Test
public void injectInto() {
ImmutableCollection<Integer> integers = this.classUnderTest();
Integer result = integers.injectInto(0, AddFunction.INTEGER);
Assert.assertEquals(
FastList.newList(integers).injectInto(0, AddFunction.INTEGER_TO_INT), result.intValue());
}
@Test
public void forEachWith() {
MutableList<String> result = Lists.mutable.of();
MutableSet<String> source = Sets.fixedSize.of("1", "2", "3", "4");
source.forEachWith(Procedures2.fromProcedure(CollectionAddProcedure.on(result)), null);
Assert.assertEquals(FastList.newListWith("1", "2", "3", "4"), result);
}
@Test
public void testRejectWith() {
Verify.assertSize(
3,
this.unmodifiableStackString.rejectWith(
Predicates2.equal(), 3, FastList.<String>newList()));
}