@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 serialization() {
int size = COLLISIONS.size();
for (int i = 1; i < size; i++) {
MutableSet<Integer> set =
UnifiedSetWithHashingStrategy.newSet(INTEGER_HASHING_STRATEGY, SIZE)
.withAll(COLLISIONS.subList(0, i));
Verify.assertPostSerializedEqualsAndHashCode(set);
set.add(null);
Verify.assertPostSerializedEqualsAndHashCode(set);
}
UnifiedSetWithHashingStrategy<Integer> nullBucketZero =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY, null, COLLISION_1, COLLISION_2);
Verify.assertPostSerializedEqualsAndHashCode(nullBucketZero);
UnifiedSetWithHashingStrategy<Integer> simpleSetWithNull =
UnifiedSetWithHashingStrategy.newSetWith(INTEGER_HASHING_STRATEGY, null, 1, 2);
Verify.assertPostSerializedEqualsAndHashCode(simpleSetWithNull);
UnifiedSetWithHashingStrategy<Person> people =
UnifiedSetWithHashingStrategy.newSet(LAST_NAME_HASHING_STRATEGY, PEOPLE);
Verify.assertPostSerializedEqualsAndHashCode(people);
// Testing the hashingStrategy is serialized correctly by making sure it is still hashing by
// last name
Verify.assertSetsEqual(LAST_NAME_HASHED_SET.castToSet(), people.withAll(PEOPLE.castToList()));
}
@Override
@Test
public void retainAll() {
super.retainAll();
MutableSet<Object> setWithNull = this.newWith((Object) null);
Assert.assertFalse(setWithNull.retainAll(FastList.newListWith((Object) null)));
Assert.assertEquals(UnifiedSet.newSetWith((Object) null), setWithNull);
}
@Test
public void testUnifiedSetKeySetToArrayDest() {
MutableSet<Integer> set = MultiReaderUnifiedSet.newSetWith(1, 2, 3, 4);
// deliberately to small to force the method to allocate one of the correct size
Integer[] dest = new Integer[2];
Integer[] result = set.toArray(dest);
Verify.assertSize(4, result);
Arrays.sort(result);
Assert.assertArrayEquals(new Integer[] {1, 2, 3, 4}, result);
}
@Test
public void forEachWithIndex() {
int[] indexSum = new int[1];
MutableList<String> result = Lists.mutable.of();
MutableSet<String> source = Sets.fixedSize.of("1", "2", "3", "4");
source.forEachWithIndex(
(each, index) -> {
result.add(each);
indexSum[0] += index;
});
Assert.assertEquals(FastList.newListWith("1", "2", "3", "4"), result);
Assert.assertEquals(6, indexSum[0]);
}
@Override
@Test
public void toArray() {
super.toArray();
int size = COLLISIONS.size();
for (int i = 1; i < size; i++) {
MutableSet<Integer> set =
UnifiedSetWithHashingStrategy.newSet(INTEGER_HASHING_STRATEGY, SIZE)
.withAll(COLLISIONS.subList(0, i));
Object[] objects = set.toArray();
Assert.assertEquals(set, UnifiedSet.newSetWith(objects));
}
MutableSet<Integer> deepChain =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY,
COLLISION_1,
COLLISION_2,
COLLISION_3,
COLLISION_4,
COLLISION_5,
COLLISION_6);
Assert.assertArrayEquals(
new Integer[] {
COLLISION_1, COLLISION_2, COLLISION_3, COLLISION_4, COLLISION_5, COLLISION_6
},
deepChain.toArray());
MutableSet<Integer> minimumChain =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY, COLLISION_1, COLLISION_2);
minimumChain.remove(COLLISION_2);
Assert.assertArrayEquals(new Integer[] {COLLISION_1}, minimumChain.toArray());
MutableSet<Integer> set =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY, COLLISION_1, COLLISION_2, COLLISION_3, COLLISION_4);
Integer[] target = {
Integer.valueOf(1),
Integer.valueOf(1),
Integer.valueOf(1),
Integer.valueOf(1),
Integer.valueOf(1),
Integer.valueOf(1)
};
Integer[] actual = set.toArray(target);
ArrayIterate.sort(actual, actual.length, Comparators.safeNullsHigh(Integer::compareTo));
Assert.assertArrayEquals(
new Integer[] {COLLISION_1, 1, COLLISION_2, COLLISION_3, COLLISION_4, null}, actual);
}
@Test
public void setKeyPreservation() {
Key key = new Key("key");
Key duplicateKey1 = new Key("key");
MutableSet<Key> set1 =
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
.with(key, duplicateKey1);
Verify.assertSize(1, set1);
Verify.assertContains(key, set1);
Assert.assertSame(key, set1.getFirst());
Key duplicateKey2 = new Key("key");
MutableSet<Key> set2 =
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
.with(key, duplicateKey1, duplicateKey2);
Verify.assertSize(1, set2);
Verify.assertContains(key, set2);
Assert.assertSame(key, set2.getFirst());
Key duplicateKey3 = new Key("key");
MutableSet<Key> set3 =
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
.with(key, new Key("not a dupe"), duplicateKey3);
Verify.assertSize(2, set3);
Verify.assertContainsAll(set3, key, new Key("not a dupe"));
Assert.assertSame(key, set3.detect(key::equals));
}
@SuppressWarnings("unchecked")
@Override
public <V> StateMachine<T> notify(final V state, final T value) {
if (strict) {
Assert.isTrue(states.contains(state), "State " + state + " has not been defined");
}
Event<T> ev = Event.wrap(value instanceof Event ? ((Event<T>) value).getData() : value);
observable.notify(
state,
ev,
new Consumer<Event<T>>() {
@Override
public void accept(final Event<T> ev) {
transition(state, ev.getData());
}
});
return this;
}
private static void assertUnifiedSetEqualsAndHashCode(int shift) {
MutableSet<CollidingInt> set1 = MultiReaderUnifiedSet.newSet();
Set<CollidingInt> set2 = new HashSet<CollidingInt>();
MutableSet<CollidingInt> set3 = MultiReaderUnifiedSet.newSet();
MutableSet<CollidingInt> set4 = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++) {
set1.add(new CollidingInt(i, shift));
set2.add(new CollidingInt(i, shift));
set3.add(new CollidingInt(i, shift));
set4.add(new CollidingInt(size - i - 1, shift));
}
Assert.assertEquals(set1, set2);
Assert.assertEquals(set1.hashCode(), set2.hashCode());
Verify.assertSetsEqual(set1, set3);
Verify.assertEqualsAndHashCode(set1, set3);
Verify.assertSetsEqual(set2, set4);
Assert.assertEquals(set4, set2);
Assert.assertEquals(set2.hashCode(), set4.hashCode());
}
@Override
public <V> StateMachine<T> on(final V state, final Function<T, T> fn) {
if (strict) {
Assert.isTrue(states.contains(state), "State " + state + " has not been defined");
}
observable.on(
(state instanceof Selector ? (Selector) state : Selectors.object(state)),
new Consumer<Event<T>>() {
@SuppressWarnings("unchecked")
@Override
public void accept(final Event<T> data) {
try {
data.setData(fn.apply(data.getData()));
} catch (Throwable t) {
observable.notify(
t.getClass(), Event.wrap(new StateException(t, state, data.getData())));
}
}
});
return this;
}
@Test
public void getFirstGetLast() {
MutableSet<String> list5 = Sets.fixedSize.of("1", "2", "3", "4");
Assert.assertEquals("1", list5.getFirst());
Assert.assertEquals("4", list5.getLast());
}
@Test
public void testClone() {
MutableSet<String> set = this.newWith();
MutableSet<String> clone = set.clone();
Assert.assertSame(clone, set);
}
@Override
public <V> boolean contains(V state) {
return states.contains(state);
}
@Override
public <V> StateMachine<T> define(V state) {
states.add(state);
return this;
}
@Test
public void addingAllToOtherSet() {
MutableSet<String> newSet = UnifiedSet.newSet(Sets.fixedSize.of("1", "2", "3", "4"));
newSet.add("5");
Verify.assertContainsAll(newSet, "1", "2", "3", "4", "5");
}
@Test
public void iterator_remove() {
int size = MORE_COLLISIONS.size();
for (int i = 0; i < size; i++) {
MutableSet<Integer> actual =
UnifiedSetWithHashingStrategy.newSet(INTEGER_HASHING_STRATEGY, SIZE)
.withAll(MORE_COLLISIONS);
Iterator<Integer> iterator = actual.iterator();
for (int j = 0; j <= i; j++) {
Assert.assertTrue(iterator.hasNext());
iterator.next();
}
iterator.remove();
MutableSet<Integer> expected =
UnifiedSetWithHashingStrategy.newSet(INTEGER_HASHING_STRATEGY, MORE_COLLISIONS);
expected.remove(MORE_COLLISIONS.get(i));
Assert.assertEquals(expected, actual);
}
// remove the last element from within a 2-level long chain that is fully populated
MutableSet<Integer> set =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY,
COLLISION_1,
COLLISION_2,
COLLISION_3,
COLLISION_4,
COLLISION_5,
COLLISION_6,
COLLISION_7);
Iterator<Integer> iterator1 = set.iterator();
for (int i = 0; i < 7; i++) {
iterator1.next();
}
iterator1.remove();
Assert.assertEquals(
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY,
COLLISION_1,
COLLISION_2,
COLLISION_3,
COLLISION_4,
COLLISION_5,
COLLISION_6),
set);
// remove the second-to-last element from a 2-level long chain that that has one empty slot
Iterator<Integer> iterator2 = set.iterator();
for (int i = 0; i < 6; i++) {
iterator2.next();
}
iterator2.remove();
Assert.assertEquals(
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY,
COLLISION_1,
COLLISION_2,
COLLISION_3,
COLLISION_4,
COLLISION_5),
set);
// Testing removing the last element in a fully populated chained bucket
UnifiedSetWithHashingStrategy<Integer> set2 =
UnifiedSetWithHashingStrategy.newSetWith(
INTEGER_HASHING_STRATEGY, COLLISION_1, COLLISION_2, COLLISION_3, COLLISION_4);
Iterator<Integer> iterator3 = set2.iterator();
for (int i = 0; i < 3; ++i) {
iterator3.next();
}
iterator3.next();
iterator3.remove();
Verify.assertSetsEqual(UnifiedSet.newSetWith(COLLISION_1, COLLISION_2, COLLISION_3), set2);
}
@Test
public void testNewEmpty() {
MutableSet<String> set = this.unmodifiableSet.newEmpty();
set.add(LED_ZEPPELIN);
Verify.assertContains(LED_ZEPPELIN, set);
}