notSmiths = people.rejectWith(Person::lastNameEquals, "Smith");
Assert.assertEquals("Watson, Williams", notSmiths.collect(Person::getLastName).makeString());
```
#### Example 3: `Any` / `All` / `None`
We can test whether any, all or none of the elements of a collection satisfy a given condition.
```java
// Any
Assert.assertTrue(people.anySatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertTrue(people.anySatisfyWith(Person::lastNameEquals, "Smith"));
// All
Assert.assertFalse(people.allSatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertFalse(people.allSatisfyWith(Person::lastNameEquals, "Smith"));
// None
Assert.assertFalse(people.noneSatisfy(person -> person.lastNameEquals("Smith"));
Assert.assertFalse(people.noneSatisfyWith(Person::lastNameEquals, "Smith"));
```
## [Back to README](./README.md)
[MutableCollection]: https://www.eclipse.org/collections/javadoc/10.4.0/org/eclipse/collections/api/collection/MutableCollection.html
[ImmutableCollection]: https://www.eclipse.org/collections/javadoc/10.4.0/org/eclipse/collections/api/collection/ImmutableCollection.html
[LazyIterable]: https://www.eclipse.org/collections/javadoc/10.4.0/org/eclipse/collections/api/LazyIterable.html
[Lists]: https://www.eclipse.org/collections/javadoc/10.4.0/org/eclipse/collections/api/factory/Lists.html
eclipse-collections-11.0.0.M3/RELEASE_NOTE_DRAFT.md 0000664 0000000 0000000 00000004200 14073445332 0021157 0 ustar 00root root 0000000 0000000 11.0.0
====================
This is the 11.0.0 major release.
The Eclipse Collections team gives a huge thank you to everyone who participated in this release.
# New Functionality
-----------------
*
# Tech Debt Reduction
---------------------
*
# OSGi Integration Improvements
-------------------------------
*
# Build Changes
-----------------
*
# Note
-------
_We have taken all the measures to ensure all features are captured in the release notes.
However, release notes compilation is manual, so it is possible that a commit might be missed.
For a comprehensive list of commits please go through the commit log._
Acquiring Eclipse Collections
-----------------------------
### Maven
```xml
org.eclipse.collections
eclipse-collections-api
11.0.0
org.eclipse.collections
eclipse-collections
11.0.0
org.eclipse.collections
eclipse-collections-testutils
11.0.0
test
org.eclipse.collections
eclipse-collections-forkjoin
11.0.0
```
### Gradle
```groovy
implementation 'org.eclipse.collections:eclipse-collections-api:11.0.0'
implementation 'org.eclipse.collections:eclipse-collections:11.0.0'
testImplementation 'org.eclipse.collections:eclipse-collections-testutils:11.0.0'
implementation 'org.eclipse.collections:eclipse-collections-forkjoin:11.0.0'
```
### Ivy
```xml
```
### OSGi Bundle
Eclipse software repository location: http://download.eclipse.org/collections/11.0.0/repository
eclipse-collections-11.0.0.M3/about.html 0000664 0000000 0000000 00000004206 14073445332 0020016 0 ustar 00root root 0000000 0000000
About Eclipse Collections 7.0
Eclipse Collections 7.0
Eclipse Collections initial release
Dec 24 2015
About
Eclipse Collections
is a collections framework for Java. It has JDK-compatible
List, Set and Map implementations with a rich API, additional types not found
in the JDK like Bags, Multimaps and set of utility classes that work with any
JDK compatible Collections, Arrays, Maps or Strings. The iteration protocol was
inspired by the Smalltalk collection framework.
License
The Eclipse Foundation makes available all content in this module ("Content").
Unless otherwise indicated below, the Content is provided to you under the terms
and conditions of the Eclipse Public License Version 1.0 ("EPL") and
Eclipse Distribution License Version 1.0 (“EDLâ€). A copy of the EPL is available at
http://www.eclipse.org/legal/epl-v10.html
and a copy of the EDL is available at
http://www.eclipse.org/org/documents/edl-v10.php. For purposes of the EPL, "Program"
will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the
Content is being redistributed by another party ("Redistributor")
and different terms and conditions may apply to your use of any object code
in the Content. Check the Redistributor’s license that was provided with
the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL and EDL still apply to any source
code in the Content and such source code may be obtained at http://www.eclipse.org.
eclipse-collections-11.0.0.M3/acceptance-tests/ 0000775 0000000 0000000 00000000000 14073445332 0021242 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/acceptance-tests.iml 0000664 0000000 0000000 00000002605 14073445332 0025176 0 ustar 00root root 0000000 0000000
eclipse-collections-11.0.0.M3/acceptance-tests/pom.xml 0000664 0000000 0000000 00000011001 14073445332 0022550 0 ustar 00root root 0000000 0000000
eclipse-collections-parent
org.eclipse.collections
11.0.0.M3
4.0.0
acceptance-tests
Eclipse Collections Acceptance Test Suite
true
true
org.eclipse.collections
eclipse-collections-api
${project.version}
test
org.eclipse.collections
eclipse-collections
${project.version}
test
org.eclipse.collections
eclipse-collections-testutils
${project.version}
test
org.eclipse.collections
eclipse-collections-forkjoin
${project.version}
test
junit
junit
test
org.slf4j
slf4j-api
test
org.slf4j
slf4j-simple
test
maven-surefire-plugin
maven-source-plugin
org.codehaus.mojo
sonar-maven-plugin
maven-checkstyle-plugin
org.codehaus.mojo
findbugs-maven-plugin
maven-enforcer-plugin
maven-dependency-plugin
3.1.2
analyze
analyze-only
true
com.google.code.findbugs:jsr305:jar
org.slf4j:slf4j-simple:jar
eclipse-collections-11.0.0.M3/acceptance-tests/src/ 0000775 0000000 0000000 00000000000 14073445332 0022031 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/ 0000775 0000000 0000000 00000000000 14073445332 0023010 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/ 0000775 0000000 0000000 00000000000 14073445332 0023731 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/ 0000775 0000000 0000000 00000000000 14073445332 0024520 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/ 0000775 0000000 0000000 00000000000 14073445332 0026144 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/ 0000775 0000000 0000000 00000000000 14073445332 0030462 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/api/ 0000775 0000000 0000000 00000000000 14073445332 0031233 5 ustar 00root root 0000000 0000000 IntIterableAcceptanceTest.java 0000664 0000000 0000000 00000004116 14073445332 0037032 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/api /*
* Copyright (c) 2021 Goldman Sachs and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.api;
import org.eclipse.collections.api.list.primitive.MutableIntList;
import org.eclipse.collections.impl.factory.primitive.IntLists;
import org.junit.Assert;
import org.junit.Test;
/**
* JUnit test for {@link IntIterable}.
*/
public class IntIterableAcceptanceTest
{
@Test
public void testContainsAllWithMillionElementIterables()
{
MutableIntList list1 = IntLists.mutable.withInitialCapacity(1_000_000);
MutableIntList list2 = IntLists.mutable.withInitialCapacity(1_000_000);
for (int i = 0; i < 1_000_000 - 1; i++)
{
list1.add(i);
list2.add(i);
}
list1.add(1_000_000);
Assert.assertTrue(list1.containsAll(list2));
}
@Test
public void testContainsAnyWithMillionElementIterable()
{
MutableIntList list = IntLists.mutable.withInitialCapacity(1_000_000);
int[] source = new int[32];
for (int i = 0; i < 1_000_000; i++)
{
if (i < source.length)
{
source[i] = 1_000_030 - i;
}
list.add(i);
}
Assert.assertTrue(list.containsAny(source));
}
@Test
public void testContainsNoneWithMillionElementIterable()
{
MutableIntList list = IntLists.mutable.withInitialCapacity(1_000_000);
int[] source = new int[32];
for (int i = 0; i < 1_000_000; i++)
{
if (i < source.length)
{
source[i] = 1_000_030 - i;
}
list.add(i);
}
Assert.assertFalse(list.containsNone(source));
}
}
eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/ 0000775 0000000 0000000 00000000000 14073445332 0031423 5 ustar 00root root 0000000 0000000 CollidingInt.java 0000664 0000000 0000000 00000003124 14073445332 0034566 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl;
import java.io.Serializable;
public class CollidingInt implements Serializable, Comparable
{
private static final long serialVersionUID = 1L;
private final int value;
private final int shift;
public CollidingInt(int value, int shift)
{
this.shift = shift;
this.value = value;
}
@Override
public boolean equals(Object o)
{
if (this == o)
{
return true;
}
if (o == null || this.getClass() != o.getClass())
{
return false;
}
CollidingInt that = (CollidingInt) o;
return this.value == that.value && this.shift == that.shift;
}
@Override
public int hashCode()
{
return this.value >> this.shift;
}
public int getValue()
{
return this.value;
}
@Override
public int compareTo(CollidingInt o)
{
int result = Integer.valueOf(this.value).compareTo(o.value);
if (result != 0)
{
return result;
}
return Integer.valueOf(this.shift).compareTo(o.shift);
}
}
concurrent/ 0000775 0000000 0000000 00000000000 14073445332 0033526 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl MultiReaderUnifiedSetAcceptanceTest.java 0000664 0000000 0000000 00000037600 14073445332 0043403 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/concurrent /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.concurrent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.impl.CollidingInt;
import org.eclipse.collections.impl.block.factory.Procedures;
import org.eclipse.collections.impl.factory.Lists;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.set.mutable.MultiReaderUnifiedSet;
import org.eclipse.collections.impl.test.SerializeTestHelper;
import org.eclipse.collections.impl.test.Verify;
import org.junit.Assert;
import org.junit.Test;
public class MultiReaderUnifiedSetAcceptanceTest
{
@Test
public void testUnifiedSet()
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
Assert.assertTrue(set.add(i));
}
Verify.assertSize(size, set);
for (int i = 0; i < size; i++)
{
Verify.assertContains(i, set);
}
for (int i = 0; i < size; i += 2)
{
Assert.assertTrue(set.remove(i));
}
Verify.assertSize(size / 2, set);
for (int i = 1; i < size; i += 2)
{
Verify.assertContains(i, set);
}
}
@Test
public void testUnifiedSetClear()
{
assertUnifiedSetClear(0);
assertUnifiedSetClear(1);
assertUnifiedSetClear(2);
assertUnifiedSetClear(3);
}
private static void assertUnifiedSetClear(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
Assert.assertTrue(set.add(new CollidingInt(i, shift)));
}
set.clear();
Verify.assertEmpty(set);
for (int i = 0; i < size; i++)
{
Verify.assertNotContains(new CollidingInt(i, shift), set);
}
}
@Test
public void testUnifiedSetForEach()
{
assertUnifiedSetForEach(0);
assertUnifiedSetForEach(1);
assertUnifiedSetForEach(2);
assertUnifiedSetForEach(3);
}
private static void assertUnifiedSetForEach(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
Assert.assertTrue(set.add(new CollidingInt(i, shift)));
}
MutableList keys = FastList.newList(size);
set.forEach(Procedures.cast(keys::add));
Verify.assertSize(size, keys);
Collections.sort(keys);
for (int i = 0; i < size; i++)
{
Verify.assertItemAtIndex(new CollidingInt(i, shift), i, keys);
}
}
@Test
public void testUnifiedSetForEachWith()
{
assertUnifiedSetForEachWith(0);
assertUnifiedSetForEachWith(1);
assertUnifiedSetForEachWith(2);
assertUnifiedSetForEachWith(3);
}
private static void assertUnifiedSetForEachWith(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
Assert.assertTrue(set.add(new CollidingInt(i, shift)));
}
MutableList keys = FastList.newList(size);
set.forEachWith((key, s) -> {
Assert.assertEquals("foo", s);
keys.add(key);
}, "foo");
Verify.assertSize(size, keys);
Collections.sort(keys);
for (int i = 0; i < size; i++)
{
Verify.assertItemAtIndex(new CollidingInt(i, shift), i, keys);
}
}
@Test
public void testUnifiedSetForEachWithIndex()
{
assertUnifiedSetForEachWithIndex(0);
assertUnifiedSetForEachWithIndex(1);
assertUnifiedSetForEachWithIndex(2);
assertUnifiedSetForEachWithIndex(3);
}
private static void assertUnifiedSetForEachWithIndex(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
Assert.assertTrue(set.add(new CollidingInt(i, shift)));
}
MutableList keys = FastList.newList(size);
int[] prevIndex = new int[1];
set.forEachWithIndex((key, index) -> {
Assert.assertEquals(prevIndex[0], index);
prevIndex[0]++;
keys.add(key);
});
Verify.assertSize(size, keys);
Collections.sort(keys);
for (int i = 0; i < size; i++)
{
Verify.assertItemAtIndex(new CollidingInt(i, shift), i, keys);
}
}
@Test
public void testUnifiedSetAddAll()
{
assertUnifiedSetAddAll(0);
assertUnifiedSetAddAll(1);
assertUnifiedSetAddAll(2);
assertUnifiedSetAddAll(3);
}
private static void assertUnifiedSetAddAll(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
MultiReaderUnifiedSet newSet = MultiReaderUnifiedSet.newSet(size);
newSet.addAll(set);
Verify.assertSize(size, newSet);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), newSet);
}
}
@Test
public void testUnifiedSetAddAllWithHashSet()
{
assertUnifiedSetAddAllWithHashSet(0);
assertUnifiedSetAddAllWithHashSet(1);
assertUnifiedSetAddAllWithHashSet(2);
assertUnifiedSetAddAllWithHashSet(3);
}
private static void assertUnifiedSetAddAllWithHashSet(int shift)
{
Set set = new HashSet<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
MultiReaderUnifiedSet newSet = MultiReaderUnifiedSet.newSet(size);
newSet.addAll(set);
Verify.assertSize(size, newSet);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), newSet);
}
MultiReaderUnifiedSet newSet2 = MultiReaderUnifiedSet.newSet();
newSet2.addAll(set);
Verify.assertSize(size, newSet2);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), newSet2);
}
}
@Test
public void testUnifiedSetReplace()
{
assertUnifiedSetReplace(0);
assertUnifiedSetReplace(1);
assertUnifiedSetReplace(2);
assertUnifiedSetReplace(3);
}
private static void assertUnifiedSetReplace(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
Verify.assertSize(size, set);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), set);
}
}
@Test
public void testUnifiedSetRetainAllFromList()
{
runUnifiedSetRetainAllFromList(0);
runUnifiedSetRetainAllFromList(1);
runUnifiedSetRetainAllFromList(2);
runUnifiedSetRetainAllFromList(3);
}
private static void runUnifiedSetRetainAllFromList(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
MutableList toRetain = Lists.mutable.of();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
if (i % 2 == 0)
{
toRetain.add(new CollidingInt(i, shift));
}
}
Verify.assertSize(size, set);
Assert.assertTrue(set.containsAll(toRetain));
Assert.assertTrue(set.retainAll(toRetain));
Assert.assertTrue(set.containsAll(toRetain));
Assert.assertFalse(set.retainAll(toRetain)); // a second call should not modify the set
Verify.assertSize(size / 2, set);
for (int i = 0; i < size; i += 2)
{
Verify.assertContains(new CollidingInt(i, shift), set);
}
}
@Test
public void testUnifiedSetRetainAllFromSet()
{
runUnifiedSetRetainAllFromSet(0);
runUnifiedSetRetainAllFromSet(1);
runUnifiedSetRetainAllFromSet(2);
runUnifiedSetRetainAllFromSet(3);
}
private static void runUnifiedSetRetainAllFromSet(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
Set toRetain = new HashSet<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
if (i % 2 == 0)
{
toRetain.add(new CollidingInt(i, shift));
}
}
Verify.assertSize(size, set);
Assert.assertTrue(set.containsAll(toRetain));
Assert.assertTrue(set.retainAll(toRetain));
Assert.assertTrue(set.containsAll(toRetain));
Assert.assertFalse(set.retainAll(toRetain)); // a second call should not modify the set
Verify.assertSize(size / 2, set);
for (int i = 0; i < size; i += 2)
{
Verify.assertContains(new CollidingInt(i, shift), set);
}
}
@Test
public void testUnifiedSetToArray()
{
runUnifiedSetToArray(0);
runUnifiedSetToArray(1);
runUnifiedSetToArray(2);
runUnifiedSetToArray(3);
}
private static void runUnifiedSetToArray(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
Verify.assertSize(size, set);
Object[] keys = set.toArray();
Assert.assertEquals(size, keys.length);
Arrays.sort(keys);
for (int i = 0; i < size; i++)
{
Verify.assertItemAtIndex(new CollidingInt(i, shift), i, keys);
}
}
@Test
public void testUnifiedSetSerialize()
{
runUnifiedSetSerialize(0);
runUnifiedSetSerialize(1);
runUnifiedSetSerialize(2);
runUnifiedSetSerialize(3);
}
private static void runUnifiedSetSerialize(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
}
set.add(null);
set = SerializeTestHelper.serializeDeserialize(set);
Verify.assertSize(size + 1, set);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), set);
}
Verify.assertContains(null, set);
}
@Test
public void testUnifiedSetKeySetToArrayDest()
{
MutableSet 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 testUnifiedSetEqualsAndHashCode()
{
assertUnifiedSetEqualsAndHashCode(0);
assertUnifiedSetEqualsAndHashCode(1);
assertUnifiedSetEqualsAndHashCode(2);
assertUnifiedSetEqualsAndHashCode(3);
}
private static void assertUnifiedSetEqualsAndHashCode(int shift)
{
MutableSet set1 = MultiReaderUnifiedSet.newSet();
Set set2 = new HashSet<>();
MutableSet set3 = MultiReaderUnifiedSet.newSet();
MutableSet 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());
}
@Test
public void testUnifiedSetRemoveAll()
{
runUnifiedSetRemoveAll(0);
runUnifiedSetRemoveAll(1);
runUnifiedSetRemoveAll(2);
runUnifiedSetRemoveAll(3);
}
private static void runUnifiedSetRemoveAll(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
List toRemove = new ArrayList<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
set.add(new CollidingInt(i, shift));
if (i % 2 == 0)
{
toRemove.add(new CollidingInt(i, shift));
}
}
Verify.assertSize(size, set);
Assert.assertTrue(set.removeAll(toRemove));
Assert.assertFalse(set.removeAll(toRemove)); // a second call should not modify the set
Verify.assertSize(size / 2, set);
for (int i = 1; i < size; i += 2)
{
Verify.assertContains(new CollidingInt(i, shift), set);
}
}
@Test
public void testUnifiedSetPutDoesNotReplace()
{
this.assertUnifiedSetPutDoesNotReplace(0);
this.assertUnifiedSetPutDoesNotReplace(1);
this.assertUnifiedSetPutDoesNotReplace(2);
this.assertUnifiedSetPutDoesNotReplace(3);
this.assertUnifiedSetPutDoesNotReplace(4);
}
private void assertUnifiedSetPutDoesNotReplace(int shift)
{
MultiReaderUnifiedSet set = MultiReaderUnifiedSet.newSet();
for (int i = 0; i < 1000; i++)
{
Assert.assertTrue(set.add(new CollidingIntWithFlag(i, shift, false)));
}
Assert.assertEquals(1000, set.size());
for (int i = 0; i < 1000; i++)
{
Assert.assertFalse(set.add(new CollidingIntWithFlag(i, shift, true)));
}
Assert.assertEquals(1000, set.size());
set.withReadLockAndDelegate(delegate -> {
for (CollidingIntWithFlag ciwf : delegate)
{
Assert.assertFalse(ciwf.isFlag());
}
});
}
private static final class CollidingIntWithFlag extends CollidingInt
{
private static final long serialVersionUID = 1L;
private final boolean flag;
private CollidingIntWithFlag(int value, int shift, boolean flag)
{
super(value, shift);
this.flag = flag;
}
public boolean isFlag()
{
return this.flag;
}
}
}
eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/forkjoin/ 0000775 0000000 0000000 00000000000 14073445332 0033244 5 ustar 00root root 0000000 0000000 FJIterateAcceptanceTest.java 0000664 0000000 0000000 00000067103 14073445332 0040463 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/forkjoin /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.forkjoin;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.atomic.AtomicInteger;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.bag.Bag;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.map.MapIterable;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.impl.bag.mutable.HashBag;
import org.eclipse.collections.impl.block.factory.Functions;
import org.eclipse.collections.impl.block.factory.HashingStrategies;
import org.eclipse.collections.impl.block.factory.Predicates;
import org.eclipse.collections.impl.block.factory.Procedures;
import org.eclipse.collections.impl.factory.Lists;
import org.eclipse.collections.impl.list.Interval;
import org.eclipse.collections.impl.list.mutable.ArrayListAdapter;
import org.eclipse.collections.impl.list.mutable.CompositeFastList;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.list.mutable.ListAdapter;
import org.eclipse.collections.impl.map.mutable.UnifiedMap;
import org.eclipse.collections.impl.parallel.AbstractProcedureCombiner;
import org.eclipse.collections.impl.parallel.ParallelIterate;
import org.eclipse.collections.impl.parallel.PassThruCombiner;
import org.eclipse.collections.impl.parallel.PassThruObjectIntProcedureFactory;
import org.eclipse.collections.impl.parallel.PassThruProcedureFactory;
import org.eclipse.collections.impl.parallel.ProcedureFactory;
import org.eclipse.collections.impl.set.mutable.MultiReaderUnifiedSet;
import org.eclipse.collections.impl.set.mutable.UnifiedSet;
import org.eclipse.collections.impl.set.strategy.mutable.UnifiedSetWithHashingStrategy;
import org.eclipse.collections.impl.test.Verify;
import org.eclipse.collections.impl.utility.ArrayIterate;
import org.eclipse.collections.impl.utility.LazyIterate;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class FJIterateAcceptanceTest
{
private static final Procedure EXCEPTION_PROCEDURE = value -> {
throw new RuntimeException("Thread death on its way!");
};
private static final ObjectIntProcedure EXCEPTION_OBJECT_INT_PROCEDURE = (object, index) -> {
throw new RuntimeException("Thread death on its way!");
};
private static final Function> INT_TO_TWO_STRINGS = integer -> Lists.fixedSize.of(integer.toString(), integer.toString());
private static final Function EVEN_OR_ODD = value -> value % 2 == 0 ? "Even" : "Odd";
private int count;
private final MutableSet threadNames = MultiReaderUnifiedSet.newSet();
private ImmutableList> iterables;
private final ForkJoinPool executor = new ForkJoinPool(2);
@Before
public void setUp()
{
Interval interval = Interval.oneTo(20000);
this.iterables = Lists.immutable.of(
interval.toList(),
interval.toList().asUnmodifiable(),
interval.toList().asSynchronized(),
interval.toList().toImmutable(),
interval.toSet(),
interval.toSet().asUnmodifiable(),
interval.toSet().asSynchronized(),
interval.toSet().toImmutable(),
interval.toBag(),
interval.toBag().asUnmodifiable(),
interval.toBag().asSynchronized(),
interval.toBag().toImmutable(),
interval.toSortedSet(),
interval.toSortedSet().asUnmodifiable(),
interval.toSortedSet().asSynchronized(),
interval.toSortedSet().toImmutable(),
interval.toMap(Functions.getPassThru(), Functions.getPassThru()),
interval.toMap(Functions.getPassThru(), Functions.getPassThru()).asUnmodifiable(),
interval.toMap(Functions.getPassThru(), Functions.getPassThru()).asSynchronized(),
interval.toMap(Functions.getPassThru(), Functions.getPassThru()).toImmutable(),
ArrayListAdapter.newList().withAll(interval),
ArrayListAdapter.newList().withAll(interval).asUnmodifiable(),
ArrayListAdapter.newList().withAll(interval).asSynchronized(),
new CompositeFastList().withAll(interval.toList()),
new CompositeFastList().withAll(interval.toList()).asUnmodifiable(),
new CompositeFastList().withAll(interval.toList()).asSynchronized(),
new CompositeFastList().withAll(interval.toList()).toImmutable(),
ListAdapter.adapt(new LinkedList()).withAll(interval),
ListAdapter.adapt(new LinkedList()).withAll(interval).asUnmodifiable(),
ListAdapter.adapt(new LinkedList()).withAll(interval).asSynchronized(),
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.defaultStrategy()).withAll(interval),
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.defaultStrategy()).withAll(interval).asUnmodifiable(),
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.defaultStrategy()).withAll(interval).asSynchronized(),
UnifiedSetWithHashingStrategy.newSet(HashingStrategies.defaultStrategy()).withAll(interval).toImmutable());
}
@After
public void tearDown()
{
this.executor.shutdown();
}
@Test
public void testOneLevelCall()
{
new RecursiveProcedure().value(1);
synchronized (this)
{
Assert.assertEquals("all iterations completed", 20000, this.count);
}
}
@Test
public void testNestedCall()
{
new RecursiveProcedure().value(2);
synchronized (this)
{
Assert.assertEquals("all iterations completed", 419980, this.count);
}
Assert.assertTrue("uses multiple threads", this.threadNames.size() > 1);
}
@Test
public void testForEachUsingSet()
{
//Tests the default batch size calculations
IntegerSum sum = new IntegerSum(0);
MutableSet set = Interval.toSet(1, 10000);
FJIterate.forEach(set, new SumProcedure(sum), new SumCombiner(sum));
Assert.assertEquals(50005000, sum.getSum());
//Testing batch size 1
IntegerSum sum2 = new IntegerSum(0);
UnifiedSet set2 = UnifiedSet.newSet(Interval.oneTo(100));
FJIterate.forEach(set2, new SumProcedure(sum2), new SumCombiner(sum2), 1, set2.getBatchCount(set2.size()));
Assert.assertEquals(5050, sum2.getSum());
//Testing an uneven batch size
IntegerSum sum3 = new IntegerSum(0);
UnifiedSet set3 = UnifiedSet.newSet(Interval.oneTo(100));
FJIterate.forEach(set3, new SumProcedure(sum3), new SumCombiner(sum3), 1, set3.getBatchCount(13));
Assert.assertEquals(5050, sum3.getSum());
//Testing divideByZero exception by passing 1 as batchSize
IntegerSum sum4 = new IntegerSum(0);
UnifiedSet set4 = UnifiedSet.newSet(Interval.oneTo(100));
FJIterate.forEach(set4, new SumProcedure(sum4), new SumCombiner(sum4), 1);
Assert.assertEquals(5050, sum4.getSum());
}
@Test
public void testForEachUsingMap()
{
//Test the default batch size calculations
IntegerSum sum1 = new IntegerSum(0);
MutableMap map1 = Interval.fromTo(1, 10000).toMap(String::valueOf, Functions.getIntegerPassThru());
FJIterate.forEach(map1, new SumProcedure(sum1), new SumCombiner(sum1));
Assert.assertEquals(50005000, sum1.getSum());
//Testing batch size 1
IntegerSum sum2 = new IntegerSum(0);
UnifiedMap map2 = (UnifiedMap) Interval.fromTo(1, 100).toMap(String::valueOf, Functions.getIntegerPassThru());
FJIterate.forEach(map2, new SumProcedure(sum2), new SumCombiner(sum2), 1, map2.getBatchCount(map2.size()));
Assert.assertEquals(5050, sum2.getSum());
//Testing an uneven batch size
IntegerSum sum3 = new IntegerSum(0);
UnifiedMap set3 = (UnifiedMap) Interval.fromTo(1, 100).toMap(String::valueOf, Functions.getIntegerPassThru());
FJIterate.forEach(set3, new SumProcedure(sum3), new SumCombiner(sum3), 1, set3.getBatchCount(13));
Assert.assertEquals(5050, sum3.getSum());
}
@Test
public void testForEach()
{
IntegerSum sum1 = new IntegerSum(0);
List list1 = FJIterateAcceptanceTest.createIntegerList(16);
FJIterate.forEach(list1, new SumProcedure(sum1), new SumCombiner(sum1), 1, list1.size() / 2);
Assert.assertEquals(16, sum1.getSum());
IntegerSum sum2 = new IntegerSum(0);
List list2 = FJIterateAcceptanceTest.createIntegerList(7);
FJIterate.forEach(list2, new SumProcedure(sum2), new SumCombiner(sum2));
Assert.assertEquals(7, sum2.getSum());
IntegerSum sum3 = new IntegerSum(0);
List list3 = FJIterateAcceptanceTest.createIntegerList(15);
FJIterate.forEach(list3, new SumProcedure(sum3), new SumCombiner(sum3), 1, list3.size() / 2);
Assert.assertEquals(15, sum3.getSum());
IntegerSum sum4 = new IntegerSum(0);
List list4 = FJIterateAcceptanceTest.createIntegerList(35);
FJIterate.forEach(list4, new SumProcedure(sum4), new SumCombiner(sum4));
Assert.assertEquals(35, sum4.getSum());
IntegerSum sum5 = new IntegerSum(0);
MutableList list5 = FastList.newList(list4);
FJIterate.forEach(list5, new SumProcedure(sum5), new SumCombiner(sum5));
Assert.assertEquals(35, sum5.getSum());
IntegerSum sum6 = new IntegerSum(0);
List list6 = FJIterateAcceptanceTest.createIntegerList(40);
FJIterate.forEach(list6, new SumProcedure(sum6), new SumCombiner(sum6), 1, list6.size() / 2);
Assert.assertEquals(40, sum6.getSum());
IntegerSum sum7 = new IntegerSum(0);
MutableList list7 = FastList.newList(list6);
FJIterate.forEach(list7, new SumProcedure(sum7), new SumCombiner(sum7), 1, list6.size() / 2);
Assert.assertEquals(40, sum7.getSum());
}
@Test
public void testForEachImmutableList()
{
IntegerSum sum1 = new IntegerSum(0);
ImmutableList list1 = Lists.immutable.ofAll(FJIterateAcceptanceTest.createIntegerList(16));
FJIterate.forEach(list1, new SumProcedure(sum1), new SumCombiner(sum1), 1, list1.size() / 2);
Assert.assertEquals(16, sum1.getSum());
IntegerSum sum2 = new IntegerSum(0);
ImmutableList list2 = Lists.immutable.ofAll(FJIterateAcceptanceTest.createIntegerList(7));
FJIterate.forEach(list2, new SumProcedure(sum2), new SumCombiner(sum2));
Assert.assertEquals(7, sum2.getSum());
IntegerSum sum3 = new IntegerSum(0);
ImmutableList list3 = Lists.immutable.ofAll(FJIterateAcceptanceTest.createIntegerList(15));
FJIterate.forEach(list3, new SumProcedure(sum3), new SumCombiner(sum3), 1, list3.size() / 2);
Assert.assertEquals(15, sum3.getSum());
IntegerSum sum4 = new IntegerSum(0);
ImmutableList list4 = Lists.immutable.ofAll(FJIterateAcceptanceTest.createIntegerList(35));
FJIterate.forEach(list4, new SumProcedure(sum4), new SumCombiner(sum4));
Assert.assertEquals(35, sum4.getSum());
IntegerSum sum5 = new IntegerSum(0);
ImmutableList list5 = FastList.newList(list4).toImmutable();
FJIterate.forEach(list5, new SumProcedure(sum5), new SumCombiner(sum5));
Assert.assertEquals(35, sum5.getSum());
IntegerSum sum6 = new IntegerSum(0);
ImmutableList list6 = Lists.immutable.ofAll(FJIterateAcceptanceTest.createIntegerList(40));
FJIterate.forEach(list6, new SumProcedure(sum6), new SumCombiner(sum6), 1, list6.size() / 2);
Assert.assertEquals(40, sum6.getSum());
IntegerSum sum7 = new IntegerSum(0);
ImmutableList list7 = FastList.newList(list6).toImmutable();
FJIterate.forEach(list7, new SumProcedure(sum7), new SumCombiner(sum7), 1, list6.size() / 2);
Assert.assertEquals(40, sum7.getSum());
}
@Test
public void testForEachWithException()
{
Verify.assertThrows(RuntimeException.class, () -> FJIterate.forEach(
FJIterateAcceptanceTest.createIntegerList(5),
new PassThruProcedureFactory<>(EXCEPTION_PROCEDURE),
new PassThruCombiner<>(),
1,
5));
}
@Test
public void testForEachWithIndexToArrayUsingFastListSerialPath()
{
Integer[] array = new Integer[200];
FastList list = (FastList) Interval.oneTo(200).toList();
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
FJIterate.forEachWithIndex(list, (each, index) -> array[index] = each);
Assert.assertArrayEquals(array, list.toArray(new Integer[]{}));
}
@Test
public void testForEachWithIndexToArrayUsingFastList()
{
Integer[] array = new Integer[200];
FastList list = (FastList) Interval.oneTo(200).toList();
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
FJIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 10, 10);
Assert.assertArrayEquals(array, list.toArray(new Integer[]{}));
}
@Test
public void testForEachWithIndexToArrayUsingImmutableList()
{
Integer[] array = new Integer[200];
ImmutableList list = Interval.oneTo(200).toList().toImmutable();
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
FJIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 10, 10);
Assert.assertArrayEquals(array, list.toArray(new Integer[]{}));
}
@Test
public void testForEachWithIndexToArrayUsingArrayList()
{
Integer[] array = new Integer[200];
MutableList list = FastList.newList(Interval.oneTo(200));
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
FJIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 10, 10);
Assert.assertArrayEquals(array, list.toArray(new Integer[]{}));
}
@Test
public void testForEachWithIndexToArrayUsingFixedArrayList()
{
Integer[] array = new Integer[10];
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
FJIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 1, 2);
Assert.assertArrayEquals(array, list.toArray(new Integer[list.size()]));
}
@Test
public void testForEachWithIndexException()
{
Verify.assertThrows(RuntimeException.class, () -> FJIterate.forEachWithIndex(
FJIterateAcceptanceTest.createIntegerList(5),
new PassThruObjectIntProcedureFactory<>(EXCEPTION_OBJECT_INT_PROCEDURE),
new PassThruCombiner<>(),
1,
5));
}
@Test
public void select()
{
this.iterables.forEach(Procedures.cast(this::basicSelect));
}
private void basicSelect(RichIterable iterable)
{
Collection actual1 = FJIterate.select(iterable, Predicates.greaterThan(10000));
Collection actual2 = FJIterate.select(iterable, Predicates.greaterThan(10000), HashBag.newBag(), 3, this.executor, true);
Collection actual3 = FJIterate.select(iterable, Predicates.greaterThan(10000), true);
RichIterable expected = iterable.select(Predicates.greaterThan(10000));
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected.toBag(), actual2);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected.toBag(), HashBag.newBag(actual3));
}
@Test
public void selectSortedSet()
{
RichIterable iterable = Interval.oneTo(20000).toSortedSet();
Collection actual1 = FJIterate.select(iterable, Predicates.greaterThan(10000));
Collection actual2 = FJIterate.select(iterable, Predicates.greaterThan(10000), true);
RichIterable expected = iterable.select(Predicates.greaterThan(10000));
Assert.assertSame(expected.getClass(), actual1.getClass());
Assert.assertSame(expected.getClass(), actual2.getClass());
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected, actual2);
}
@Test
public void count()
{
this.iterables.forEach(Procedures.cast(this::basicCount));
}
private void basicCount(RichIterable listIterable)
{
int actual1 = FJIterate.count(listIterable, Predicates.greaterThan(10000));
int actual2 = FJIterate.count(listIterable, Predicates.greaterThan(10000), 11, this.executor);
Assert.assertEquals(10000, actual1);
Assert.assertEquals(10000, actual2);
}
@Test
public void reject()
{
this.iterables.forEach(Procedures.cast(this::basicReject));
}
private void basicReject(RichIterable iterable)
{
Collection actual1 = FJIterate.reject(iterable, Predicates.greaterThan(10000));
Collection actual2 = FJIterate.reject(iterable, Predicates.greaterThan(10000), HashBag.newBag(), 3, this.executor, true);
Collection actual3 = FJIterate.reject(iterable, Predicates.greaterThan(10000), true);
RichIterable expected = iterable.reject(Predicates.greaterThan(10000));
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected.toBag(), actual2);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected.toBag(), HashBag.newBag(actual3));
}
@Test
public void collect()
{
this.iterables.forEach(Procedures.cast(this::basicCollect));
}
private void basicCollect(RichIterable iterable)
{
Collection actual1 = FJIterate.collect(iterable, String::valueOf);
Collection actual2 = FJIterate.collect(iterable, String::valueOf, HashBag.newBag(), 3, this.executor, false);
Collection actual3 = FJIterate.collect(iterable, String::valueOf, true);
RichIterable expected = iterable.collect(String::valueOf);
Verify.assertSize(20000, actual1);
Verify.assertContains(String.valueOf(20000), actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected.toBag(), actual2);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected.toBag(), HashBag.newBag(actual3));
}
@Test
public void collectIf()
{
this.iterables.forEach(Procedures.cast(this::basicCollectIf));
}
private void basicCollectIf(RichIterable collection)
{
Predicate greaterThan = Predicates.greaterThan(10000);
Collection actual1 = FJIterate.collectIf(collection, greaterThan, String::valueOf);
Collection actual2 = FJIterate.collectIf(collection, greaterThan, String::valueOf, HashBag.newBag(), 3, this.executor, true);
Collection actual3 = FJIterate.collectIf(collection, greaterThan, String::valueOf, HashBag.newBag(), 3, this.executor, true);
Bag expected = collection.collectIf(greaterThan, String::valueOf).toBag();
Verify.assertSize(10000, actual1);
Verify.assertNotContains(String.valueOf(9000), actual1);
Verify.assertNotContains(String.valueOf(21000), actual1);
Verify.assertContains(String.valueOf(15976), actual1);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected, HashBag.newBag(actual1));
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected, actual2);
Assert.assertEquals(expected.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected, actual3);
}
@Test
public void flatCollect()
{
this.iterables.forEach(Procedures.cast(this::basicFlatCollect));
}
private void basicFlatCollect(RichIterable iterable)
{
Collection actual1 = FJIterate.flatCollect(iterable, INT_TO_TWO_STRINGS);
Collection actual2 = FJIterate.flatCollect(iterable, INT_TO_TWO_STRINGS, HashBag.newBag(), 3, this.executor, false);
Collection actual3 = FJIterate.flatCollect(iterable, INT_TO_TWO_STRINGS, true);
RichIterable expected1 = iterable.flatCollect(INT_TO_TWO_STRINGS);
RichIterable expected2 = iterable.flatCollect(INT_TO_TWO_STRINGS, HashBag.newBag());
Verify.assertContains(String.valueOf(20000), actual1);
Assert.assertEquals(expected1.getClass().getSimpleName() + '/' + actual1.getClass().getSimpleName(), expected1, actual1);
Assert.assertEquals(expected2.getClass().getSimpleName() + '/' + actual2.getClass().getSimpleName(), expected2, actual2);
Assert.assertEquals(expected1.getClass().getSimpleName() + '/' + actual3.getClass().getSimpleName(), expected1.toBag(), HashBag.newBag(actual3));
}
@Test
public void aggregateInPlaceBy()
{
Procedure2 countAggregator = (aggregate, value) -> aggregate.incrementAndGet();
List list = Interval.oneTo(20000);
MutableMap aggregation =
FJIterate.aggregateInPlaceBy(list, EVEN_OR_ODD, AtomicInteger::new, countAggregator);
Assert.assertEquals(10000, aggregation.get("Even").intValue());
Assert.assertEquals(10000, aggregation.get("Odd").intValue());
FJIterate.aggregateInPlaceBy(list, EVEN_OR_ODD, AtomicInteger::new, countAggregator, aggregation);
Assert.assertEquals(20000, aggregation.get("Even").intValue());
Assert.assertEquals(20000, aggregation.get("Odd").intValue());
}
@Test
public void aggregateInPlaceByWithBatchSize()
{
MutableList list = LazyIterate.adapt(Collections.nCopies(1000, 1))
.concatenate(Collections.nCopies(2000, 2))
.concatenate(Collections.nCopies(3000, 3))
.toList()
.shuffleThis();
MapIterable aggregation =
FJIterate.aggregateInPlaceBy(list, String::valueOf, AtomicInteger::new, AtomicInteger::addAndGet, 100);
Assert.assertEquals(1000, aggregation.get("1").intValue());
Assert.assertEquals(4000, aggregation.get("2").intValue());
Assert.assertEquals(9000, aggregation.get("3").intValue());
}
private static List createIntegerList(int size)
{
return Collections.nCopies(size, Integer.valueOf(1));
}
private class RecursiveProcedure implements Procedure
{
private static final long serialVersionUID = 1L;
private final ForkJoinPool executorService = new ForkJoinPool(ParallelIterate.getDefaultMaxThreadPoolSize());
@Override
public void value(Integer level)
{
if (level > 0)
{
FJIterateAcceptanceTest.this.threadNames.add(Thread.currentThread().getName());
this.executeFJIterate(level - 1, this.executorService);
}
else
{
this.simulateWork();
}
}
private void simulateWork()
{
synchronized (FJIterateAcceptanceTest.this)
{
FJIterateAcceptanceTest.this.count++;
}
}
private void executeFJIterate(int level, ForkJoinPool executorService)
{
MutableList items = Lists.mutable.of();
for (int i = 0; i < 20000; i++)
{
items.add(i % 1000 == 0 ? level : 0);
}
FJIterate.forEach(items, new RecursiveProcedure(), executorService);
}
}
public static final class IntegerSum
{
private int sum;
public IntegerSum(int newSum)
{
this.sum = newSum;
}
public IntegerSum add(int value)
{
this.sum += value;
return this;
}
public int getSum()
{
return this.sum;
}
}
public static final class SumProcedure
implements Procedure, Function2, ProcedureFactory
{
private static final long serialVersionUID = 1L;
private final IntegerSum sum;
public SumProcedure(IntegerSum newSum)
{
this.sum = newSum;
}
@Override
public SumProcedure create()
{
return new SumProcedure(new IntegerSum(0));
}
@Override
public IntegerSum value(IntegerSum s1, Integer s2)
{
return s1.add(s2);
}
@Override
public void value(Integer object)
{
this.sum.add(object);
}
public int getSum()
{
return this.sum.getSum();
}
}
public static final class SumCombiner extends AbstractProcedureCombiner
{
private static final long serialVersionUID = 1L;
private final IntegerSum sum;
public SumCombiner(IntegerSum initialSum)
{
super(true);
this.sum = initialSum;
}
@Override
public void combineOne(SumProcedure sumProcedure)
{
this.sum.add(sumProcedure.getSum());
}
}
}
eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/list/ 0000775 0000000 0000000 00000000000 14073445332 0032376 5 ustar 00root root 0000000 0000000 mutable/ 0000775 0000000 0000000 00000000000 14073445332 0033750 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/list MultiReaderFastListAcceptanceTest.java 0000664 0000000 0000000 00000002146 14073445332 0043314 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/list/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.list.mutable;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.impl.list.Interval;
import org.eclipse.collections.impl.test.Verify;
import org.junit.Test;
/**
* JUnit test for {@link MultiReaderFastList}.
*/
public class MultiReaderFastListAcceptanceTest
{
@Test
public void sortThisOnListWithMoreThan9Elements()
{
MutableList integers = MultiReaderFastList.newList(Interval.toReverseList(1, 10000));
Verify.assertStartsWith(integers.sortThis(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Verify.assertEndsWith(integers, 9997, 9998, 9999, 10000);
}
}
eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/ 0000775 0000000 0000000 00000000000 14073445332 0032200 5 ustar 00root root 0000000 0000000 mutable/ 0000775 0000000 0000000 00000000000 14073445332 0033552 5 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map ConcurrentHashMapAcceptanceTest.java 0000664 0000000 0000000 00000024700 14073445332 0042613 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.Collections;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.eclipse.collections.api.bag.MutableBag;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.Function3;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.bag.mutable.HashBag;
import org.eclipse.collections.impl.block.factory.Functions;
import org.eclipse.collections.impl.factory.Maps;
import org.eclipse.collections.impl.list.Interval;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.parallel.ParallelIterate;
import org.eclipse.collections.impl.test.Verify;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* JUnit test for {@link ConcurrentHashMap}.
*/
public class ConcurrentHashMapAcceptanceTest
{
private static final MutableMap> BAG_MUTABLE_MAP = Interval.oneTo(1000).groupBy(each -> each % 100).toMap(HashBag::new);
private ExecutorService executor;
@Before
public void setUp()
{
this.executor = Executors.newFixedThreadPool(20);
}
@After
public void tearDown()
{
this.executor.shutdown();
}
@Test
public void parallelGroupByIntoConcurrentHashMap()
{
MutableMap> actual = ConcurrentHashMap.newMap();
ParallelIterate.forEach(
Interval.oneTo(1000000),
each -> actual.getIfAbsentPut(each % 100000, () -> HashBag.newBag().asSynchronized()).add(each),
10,
this.executor);
Verify.assertEqualsAndHashCode(Interval.oneTo(1000000).groupBy(each -> each % 100000).toMap(HashBag::new), actual);
}
@Test
public void parallelForEachValue()
{
ConcurrentHashMap source =
ConcurrentHashMap.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
MutableMap> actual = ConcurrentHashMap.newMap();
Procedure procedure = each -> actual.getIfAbsentPut(each % 100, () -> HashBag.newBag().asSynchronized()).add(each);
source.parallelForEachValue(FastList.newList(Collections.nCopies(5, procedure)), this.executor);
Verify.assertEqualsAndHashCode(BAG_MUTABLE_MAP, actual);
}
@Test
public void parallelForEachEntry()
{
ConcurrentHashMap source =
ConcurrentHashMap.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
MutableMap> actual = ConcurrentHashMap.newMap();
Procedure2 procedure2 = (key, value) -> actual.getIfAbsentPut(value % 100, () -> HashBag.newBag().asSynchronized()).add(value);
source.parallelForEachKeyValue(FastList.newList(Collections.nCopies(5, procedure2)), this.executor);
Verify.assertEqualsAndHashCode(BAG_MUTABLE_MAP, actual);
}
@Test
public void putAllInParallelSmallMap()
{
ConcurrentHashMap source = ConcurrentHashMap.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
ConcurrentHashMap target = ConcurrentHashMap.newMap();
target.putAllInParallel(source, 10, this.executor);
Verify.assertEqualsAndHashCode(source, target);
}
@Test
public void putAllInParallelLargeMap()
{
ConcurrentHashMap source = ConcurrentHashMap.newMap(Interval.oneTo(60000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
ConcurrentHashMap target = ConcurrentHashMap.newMap();
target.putAllInParallel(source, 10, this.executor);
Verify.assertEqualsAndHashCode(source, target);
}
@Test
public void concurrentPutGetPutAllRemoveContainsKeyContainsValueGetIfAbsentPutTest()
{
ConcurrentHashMap map1 = ConcurrentHashMap.newMap();
ConcurrentHashMap map2 = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
map1.put(each, each);
Assert.assertEquals(each, map1.get(each));
map2.putAll(Maps.mutable.of(each, each));
map1.remove(each);
map1.putAll(Maps.mutable.of(each, each));
Assert.assertEquals(each, map2.get(each));
map2.remove(each);
Assert.assertNull(map2.get(each));
Assert.assertFalse(map2.containsValue(each));
Assert.assertFalse(map2.containsKey(each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
Assert.assertTrue(map2.containsValue(each));
Assert.assertTrue(map2.containsKey(each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
map2.remove(each);
Assert.assertEquals(each, map2.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
Assert.assertEquals(each, map2.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
}, 10, this.executor);
Verify.assertEqualsAndHashCode(map1, map2);
}
@Test
public void concurrentPutIfAbsentGetIfPresentPutTest()
{
ConcurrentHashMap map1 = ConcurrentHashMap.newMap();
ConcurrentHashMap map2 = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
map1.put(each, each);
map1.put(each, each);
Assert.assertEquals(each, map1.get(each));
map2.putAll(Maps.mutable.of(each, each));
map2.putAll(Maps.mutable.of(each, each));
map1.remove(each);
Assert.assertNull(map1.putIfAbsentGetIfPresent(each, new KeyTransformer(), new ValueFactory(), null, null));
Assert.assertEquals(each, map1.putIfAbsentGetIfPresent(each, new KeyTransformer(), new ValueFactory(), null, null));
}, 10, this.executor);
Assert.assertEquals(map1, map2);
}
@Test
public void concurrentClear()
{
ConcurrentHashMap map = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
for (int i = 0; i < each; i++)
{
map.put(each + i * 1000, each);
}
map.clear();
for (int i = 0; i < 100; i++)
{
map.put(each + i * 1000, each);
}
map.clear();
}, 10, this.executor);
Verify.assertEmpty(map);
}
@Test
public void concurrentRemoveAndPutIfAbsent()
{
ConcurrentHashMap map1 = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
Assert.assertNull(map1.put(each, each));
map1.remove(each);
Assert.assertNull(map1.get(each));
Assert.assertEquals(each, map1.getIfAbsentPut(each, Functions.getIntegerPassThru()));
map1.remove(each);
Assert.assertNull(map1.get(each));
Assert.assertEquals(each, map1.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
map1.remove(each);
Assert.assertNull(map1.get(each));
for (int i = 0; i < each; i++)
{
Assert.assertNull(map1.putIfAbsent(each + i * 1000, each));
}
for (int i = 0; i < each; i++)
{
Assert.assertEquals(each, map1.putIfAbsent(each + i * 1000, each));
}
for (int i = 0; i < each; i++)
{
Assert.assertEquals(each, map1.remove(each + i * 1000));
}
}, 10, this.executor);
}
private static class KeyTransformer implements Function2
{
private static final long serialVersionUID = 1L;
@Override
public Integer value(Integer key, Integer value)
{
return key;
}
}
private static class ValueFactory implements Function3
{
private static final long serialVersionUID = 1L;
@Override
public Integer value(Object argument1, Object argument2, Integer key)
{
return key;
}
}
@Test
public void size()
{
ConcurrentHashMap map = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(10_000), each -> map.put(each, each));
Assert.assertEquals(10_000, map.size());
Assert.assertEquals(10_000, map.keySet().size());
Assert.assertEquals(10_000, map.values().size());
Assert.assertEquals(10_000, map.entrySet().size());
}
@Test
public void size_entrySet()
{
ConcurrentHashMap map = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(10_000), each -> map.put(each, each));
Assert.assertEquals(10_000, map.entrySet().size());
}
@Test
public void size_keySet()
{
ConcurrentHashMap map = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(10_000), each -> map.put(each, each));
Assert.assertEquals(10_000, map.keySet().size());
}
@Test
public void size_values()
{
ConcurrentHashMap map = ConcurrentHashMap.newMap();
ParallelIterate.forEach(Interval.oneTo(10_000), each -> map.put(each, each));
Assert.assertEquals(10_000, map.values().size());
}
}
ConcurrentHashMapUnsafeAcceptanceTest.java 0000664 0000000 0000000 00000022613 14073445332 0043756 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.Collections;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.eclipse.collections.api.bag.MutableBag;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.Function3;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.bag.mutable.HashBag;
import org.eclipse.collections.impl.block.factory.Functions;
import org.eclipse.collections.impl.factory.Maps;
import org.eclipse.collections.impl.list.Interval;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.parallel.ParallelIterate;
import org.eclipse.collections.impl.test.Verify;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* JUnit test for {@link ConcurrentHashMapUnsafe}.
*/
public class ConcurrentHashMapUnsafeAcceptanceTest
{
private static final MutableMap> BAG_MUTABLE_MAP =
Interval.oneTo(1000).groupBy(each -> each % 100).toMap(HashBag::new);
private ExecutorService executor;
@Before
public void setUp()
{
this.executor = Executors.newFixedThreadPool(20);
}
@After
public void tearDown()
{
this.executor.shutdown();
}
@Test
public void parallelGroupByIntoConcurrentHashMap()
{
MutableMap> actual = ConcurrentHashMapUnsafe.newMap();
ParallelIterate.forEach(
Interval.oneTo(1000000),
each -> actual.getIfAbsentPut(each % 100000, () -> HashBag.newBag().asSynchronized()).add(each),
10,
this.executor);
Verify.assertEqualsAndHashCode(Interval.oneTo(1000000).groupBy(each -> each % 100000).toMap(HashBag::new), actual);
}
@Test
public void parallelForEachValue()
{
ConcurrentHashMapUnsafe source =
ConcurrentHashMapUnsafe.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
MutableMap> actual = ConcurrentHashMapUnsafe.newMap();
Procedure procedure = each -> actual.getIfAbsentPut(each % 100, () -> HashBag.newBag().asSynchronized()).add(each);
source.parallelForEachValue(FastList.newList(Collections.nCopies(5, procedure)), this.executor);
Verify.assertEqualsAndHashCode(BAG_MUTABLE_MAP, actual);
}
@Test
public void parallelForEachEntry()
{
ConcurrentHashMapUnsafe source =
ConcurrentHashMapUnsafe.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
MutableMap> actual = ConcurrentHashMapUnsafe.newMap();
Procedure2 procedure2 = (key, value) -> actual.getIfAbsentPut(value % 100, () -> HashBag.newBag().asSynchronized()).add(value);
source.parallelForEachKeyValue(FastList.newList(Collections.nCopies(5, procedure2)), this.executor);
Verify.assertEqualsAndHashCode(BAG_MUTABLE_MAP, actual);
}
@Test
public void putAllInParallelSmallMap()
{
ConcurrentHashMapUnsafe source = ConcurrentHashMapUnsafe.newMap(Interval.oneTo(1000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
ConcurrentHashMapUnsafe target = ConcurrentHashMapUnsafe.newMap();
target.putAllInParallel(source, 10, this.executor);
Verify.assertEqualsAndHashCode(source, target);
}
@Test
public void putAllInParallelLargeMap()
{
ConcurrentHashMapUnsafe source = ConcurrentHashMapUnsafe.newMap(Interval.oneTo(600000).toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru()));
ConcurrentHashMapUnsafe target = ConcurrentHashMapUnsafe.newMap();
target.putAllInParallel(source, 10, this.executor);
Verify.assertEqualsAndHashCode(source, target);
}
@Test
public void concurrentPutGetPutAllRemoveContainsKeyContainsValueGetIfAbsentPutTest()
{
ConcurrentHashMapUnsafe map1 = ConcurrentHashMapUnsafe.newMap();
ConcurrentHashMapUnsafe map2 = ConcurrentHashMapUnsafe.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
map1.put(each, each);
Assert.assertEquals(each, map1.get(each));
map2.putAll(Maps.mutable.of(each, each));
map1.remove(each);
map1.putAll(Maps.mutable.of(each, each));
Assert.assertEquals(each, map2.get(each));
map2.remove(each);
Assert.assertNull(map2.get(each));
Assert.assertFalse(map2.containsValue(each));
Assert.assertFalse(map2.containsKey(each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
Assert.assertTrue(map2.containsValue(each));
Assert.assertTrue(map2.containsKey(each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
map2.remove(each);
Assert.assertEquals(each, map2.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
Assert.assertEquals(each, map2.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
Assert.assertEquals(each, map2.getIfAbsentPut(each, Functions.getIntegerPassThru()));
}, 10, this.executor);
Verify.assertEqualsAndHashCode(map1, map2);
}
@Test
public void concurrentPutIfAbsentGetIfPresentPutTest()
{
ConcurrentHashMapUnsafe map1 = ConcurrentHashMapUnsafe.newMap();
ConcurrentHashMapUnsafe map2 = ConcurrentHashMapUnsafe.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
map1.put(each, each);
map1.put(each, each);
Assert.assertEquals(each, map1.get(each));
map2.putAll(Maps.mutable.of(each, each));
map2.putAll(Maps.mutable.of(each, each));
map1.remove(each);
Assert.assertNull(map1.putIfAbsentGetIfPresent(each, new KeyTransformer(), new ValueFactory(), null, null));
Assert.assertEquals(each, map1.putIfAbsentGetIfPresent(each, new KeyTransformer(), new ValueFactory(), null, null));
}, 10, this.executor);
Assert.assertEquals(map1, map2);
}
@Test
public void concurrentClear()
{
ConcurrentHashMapUnsafe map = ConcurrentHashMapUnsafe.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
for (int i = 0; i < each; i++)
{
map.put(each + i * 1000, each);
}
map.clear();
for (int i = 0; i < 100; i++)
{
map.put(each + i * 1000, each);
}
map.clear();
}, 10, this.executor);
Verify.assertEmpty(map);
}
@Test
public void concurrentRemoveAndPutIfAbsent()
{
ConcurrentHashMapUnsafe map1 = ConcurrentHashMapUnsafe.newMap();
ParallelIterate.forEach(Interval.oneTo(1000), each -> {
Assert.assertNull(map1.put(each, each));
map1.remove(each);
Assert.assertNull(map1.get(each));
Assert.assertEquals(each, map1.getIfAbsentPut(each, Functions.getIntegerPassThru()));
map1.remove(each);
Assert.assertNull(map1.get(each));
Assert.assertEquals(each, map1.getIfAbsentPutWith(each, Functions.getIntegerPassThru(), each));
map1.remove(each);
Assert.assertNull(map1.get(each));
for (int i = 0; i < each; i++)
{
Assert.assertNull(map1.putIfAbsent(each + i * 1000, each));
}
for (int i = 0; i < each; i++)
{
Assert.assertEquals(each, map1.putIfAbsent(each + i * 1000, each));
}
for (int i = 0; i < each; i++)
{
Assert.assertEquals(each, map1.remove(each + i * 1000));
}
}, 10, this.executor);
}
private static class KeyTransformer implements Function2
{
private static final long serialVersionUID = 1L;
@Override
public Integer value(Integer key, Integer value)
{
return key;
}
}
private static class ValueFactory implements Function3
{
private static final long serialVersionUID = 1L;
@Override
public Integer value(Object argument1, Object argument2, Integer key)
{
return key;
}
}
}
ParallelMapIteratePutAcceptanceTest.java 0000664 0000000 0000000 00000014115 14073445332 0043427 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.eclipse.collections.impl.set.mutable.UnifiedSet;
import org.eclipse.collections.impl.test.Verify;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ParallelMapIteratePutAcceptanceTest
{
private static final Logger LOGGER = LoggerFactory.getLogger(ParallelMapIteratePutAcceptanceTest.class);
private static final long SEED = 0x12345678ABCDL;
private static final long PUT_REPEAT = 100;
private static final int CHUNK_SIZE = 16000;
private static final int MAX_THREADS = 48;
@After
public void tearDown()
{
ParallelMapIteratePutAcceptanceTest.fullGc();
}
private static void fullGc()
{
System.gc();
Thread.yield();
System.gc();
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
throw new RuntimeException(e);
}
}
@Test
public void testMapIteratePut()
{
int constSize = 100000;
int size = 10000000;
Integer[] contents = new Integer[size];
Integer[] constContents = new Integer[constSize];
for (int i = 0; i < size; i++)
{
contents[i] = i;
if (i < constSize / 2)
{
constContents[i] = i;
}
else if (i < constSize)
{
constContents[i] = size - i;
}
}
Collections.shuffle(Arrays.asList(contents), new Random(SEED));
this.runAllPutTests(contents, constContents);
}
private void runAllPutTests(Integer[] contents, Integer[] constContents)
{
ExecutorService executorService = new ThreadPoolExecutor(MAX_THREADS, MAX_THREADS, 0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(MAX_THREADS));
int threads = 10;
this.runPutTest1(threads, contents, constContents, executorService, false);
executorService.shutdown();
}
private void runPutTest1(int threadCount, Integer[] contents, Integer[] constContents, ExecutorService executorService, boolean warmup)
{
long ops = ((warmup ? 1000000 : 1000000 * PUT_REPEAT) / contents.length) + 1;
Future[] futures = new Future[threadCount];
for (int i = 0; i < ops; i++)
{
ConcurrentHashMap map = new ConcurrentHashMap<>(constContents.length);
UnifiedSet setToRemove = UnifiedSet.newSet(constContents.length);
for (Integer x : constContents)
{
map.put(x, x);
setToRemove.put(x);
}
AtomicInteger currentPos = new AtomicInteger();
for (int t = 0; t < threadCount; t++)
{
futures[t] = executorService.submit(new PutRunner1(map, contents, currentPos));
}
int count = 0;
UnifiedSet setToAdd = UnifiedSet.newSet(constContents.length);
for (Integer next : map.keySet())
{
setToRemove.remove(next);
Assert.assertTrue(setToAdd.add(next));
count++;
}
Assert.assertTrue(count >= constContents.length);
Verify.assertEmpty(setToRemove);
for (Future future : futures)
{
try
{
future.get();
}
catch (ExecutionException | InterruptedException e)
{
throw new RuntimeException("unexpected", e);
}
}
if (map.size() != contents.length)
{
throw new AssertionError();
}
}
}
private static final class PutRunner1 implements Runnable
{
private final Map map;
private final Integer[] contents;
private long total;
private final AtomicInteger queuePosition;
private PutRunner1(Map map, Integer[] contents, AtomicInteger queuePosition)
{
this.map = map;
this.contents = contents;
this.queuePosition = queuePosition;
}
@Override
public void run()
{
while (this.queuePosition.get() < this.contents.length)
{
int end = this.queuePosition.addAndGet(CHUNK_SIZE);
int start = end - CHUNK_SIZE;
if (start < this.contents.length)
{
if (end > this.contents.length)
{
end = this.contents.length;
}
for (int i = start; i < end; i++)
{
if (this.map.put(this.contents[i], this.contents[i]) != null)
{
this.total++;
}
}
}
LOGGER.info("Processed chunk ending at: {}", end);
}
if (this.total < 0)
{
throw new AssertionError("never gets here, but it can't be optimized away");
}
}
}
}
ParallelUnsafeMapIteratePutAcceptanceTest.java 0000664 0000000 0000000 00000014102 14073445332 0044565 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.eclipse.collections.impl.set.mutable.UnifiedSet;
import org.eclipse.collections.impl.test.Verify;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ParallelUnsafeMapIteratePutAcceptanceTest
{
private static final Logger LOGGER = LoggerFactory.getLogger(ParallelUnsafeMapIteratePutAcceptanceTest.class);
private static final long SEED = 0x12345678ABCDL;
private static final long PUT_REPEAT = 100;
private static final int CHUNK_SIZE = 16000;
private static final int MAX_THREADS = 48;
@After
public void tearDown()
{
fullGc();
}
private static void fullGc()
{
System.gc();
Thread.yield();
System.gc();
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
throw new RuntimeException(e);
}
}
@Test
public void testMapIteratePut()
{
int constSize = 100000;
int size = 10000000;
Integer[] contents = new Integer[size];
Integer[] constContents = new Integer[constSize];
for (int i = 0; i < size; i++)
{
contents[i] = i;
if (i < constSize / 2)
{
constContents[i] = i;
}
else if (i < constSize)
{
constContents[i] = size - i;
}
}
Collections.shuffle(Arrays.asList(contents), new Random(SEED));
this.runAllPutTests(contents, constContents);
}
private void runAllPutTests(Integer[] contents, Integer[] constContents)
{
ExecutorService executorService = new ThreadPoolExecutor(MAX_THREADS, MAX_THREADS, 0, TimeUnit.SECONDS, new LinkedBlockingDeque<>(MAX_THREADS));
int threads = 10;
this.runPutTest1(threads, contents, constContents, executorService, false);
executorService.shutdown();
}
private void runPutTest1(int threadCount, Integer[] contents, Integer[] constContents, ExecutorService executorService, boolean warmup)
{
long ops = ((warmup ? 1000000 : 1000000 * PUT_REPEAT) / contents.length) + 1;
Future[] futures = new Future[threadCount];
for (int i = 0; i < ops; i++)
{
ConcurrentHashMapUnsafe map = new ConcurrentHashMapUnsafe<>(constContents.length);
UnifiedSet setToRemove = UnifiedSet.newSet(constContents.length);
for (Integer x : constContents)
{
map.put(x, x);
setToRemove.put(x);
}
AtomicInteger currentPos = new AtomicInteger();
for (int t = 0; t < threadCount; t++)
{
futures[t] = executorService.submit(new PutRunner1(map, contents, currentPos));
}
int count = 0;
UnifiedSet setToAdd = UnifiedSet.newSet(constContents.length);
for (Integer next : map.keySet())
{
setToRemove.remove(next);
Assert.assertTrue(setToAdd.add(next));
count++;
}
Assert.assertTrue(count >= constContents.length);
Verify.assertEmpty(setToRemove);
for (Future future : futures)
{
try
{
future.get();
}
catch (ExecutionException | InterruptedException e)
{
throw new RuntimeException("unexpected", e);
}
}
if (map.size() != contents.length)
{
throw new AssertionError();
}
}
}
private static final class PutRunner1 implements Runnable
{
private final Map map;
private final Integer[] contents;
private long total;
private final AtomicInteger queuePosition;
private PutRunner1(Map map, Integer[] contents, AtomicInteger queuePosition)
{
this.map = map;
this.contents = contents;
this.queuePosition = queuePosition;
}
@Override
public void run()
{
while (this.queuePosition.get() < this.contents.length)
{
int end = this.queuePosition.addAndGet(CHUNK_SIZE);
int start = end - CHUNK_SIZE;
if (start < this.contents.length)
{
if (end > this.contents.length)
{
end = this.contents.length;
}
for (int i = start; i < end; i++)
{
if (this.map.put(this.contents[i], this.contents[i]) != null)
{
this.total++;
}
}
}
LOGGER.info("Processed chunk ending at: {}", end);
}
if (this.total < 0)
{
throw new AssertionError("never gets here, but it can't be optimized away");
}
}
}
}
UnifiedMapAcceptanceTest.java 0000664 0000000 0000000 00000173500 14073445332 0041253 0 ustar 00root root 0000000 0000000 eclipse-collections-11.0.0.M3/acceptance-tests/src/test/java/org/eclipse/collections/impl/map/mutable /*
* Copyright (c) 2021 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.map.mutable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.CollidingInt;
import org.eclipse.collections.impl.test.SerializeTestHelper;
import org.eclipse.collections.impl.test.Verify;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class UnifiedMapAcceptanceTest
{
private static final Logger LOGGER = LoggerFactory.getLogger(UnifiedMapAcceptanceTest.class);
private static final Comparator> ENTRY_COMPARATOR = (o1, o2) -> o1.getKey().compareTo(o2.getKey());
private static final Comparator VALUE_COMPARATOR = (o1, o2) -> Integer.parseInt(o1.substring(1)) - Integer.parseInt(o2.substring(1));
@Test
public void forEachWithIndexWithChainedValues()
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, 3), UnifiedMapAcceptanceTest.createVal(i));
}
int[] intArray = new int[1];
intArray[0] = -1;
map.forEachWithIndex((value, index) -> {
Assert.assertEquals(index, intArray[0] + 1);
intArray[0] = index;
});
}
@Test
public void getMapMemoryUsedInWords()
{
UnifiedMap map = UnifiedMap.newMap();
Assert.assertEquals(34, map.getMapMemoryUsedInWords());
map.put("1", "1");
Assert.assertEquals(34, map.getMapMemoryUsedInWords());
}
@Test
public void getCollidingBuckets()
{
UnifiedMap map = UnifiedMap.newMap();
Assert.assertEquals(0, map.getCollidingBuckets());
}
private static String createVal(int i)
{
return "X" + i;
}
//todo: tests with null values
//todo: keyset.removeAll(some collection where one of the keys is associated with null in the map) == true
//todo: entryset.add(key associated with null) == true
//todo: entryset.contains(entry with null value) == true
@Test
public void unifiedMapWithCollisions()
{
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(0, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(1, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(2, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(3, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(4, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(0, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(1, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(2, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(3, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(4, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(0, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(1, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(2, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(3, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisions(4, 8);
}
private static void assertUnifiedMapWithCollisions(int shift, int removeStride)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
for (int i = 0; i < size; i++)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
for (int i = 0; i < size; i += removeStride)
{
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), map.remove(new CollidingInt(i, shift)));
}
Verify.assertSize(size - size / removeStride, map);
for (int i = 0; i < size; i++)
{
if (i % removeStride == 0)
{
Verify.assertNotContainsKey(new CollidingInt(i, shift), map);
Assert.assertNull(map.get(new CollidingInt(i, shift)));
}
else
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
for (int i = 0; i < size; i++)
{
map.remove(new CollidingInt(i, shift));
}
Verify.assertSize(0, map);
}
@Test
public void unifiedMapWithCollisionsAndNullKey()
{
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(0, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(1, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(2, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(3, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(4, 2);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(0, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(1, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(2, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(3, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(4, 4);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(0, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(1, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(2, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(3, 8);
UnifiedMapAcceptanceTest.assertUnifiedMapWithCollisionsAndNullKey(4, 8);
}
private static void assertUnifiedMapWithCollisionsAndNullKey(int shift, int removeStride)
{
UnifiedMap map = UnifiedMap.newMap();
Assert.assertTrue(map.isEmpty());
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
map.put(null, "Y");
Verify.assertSize(size + 1, map);
for (int i = 0; i < size; i++)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
Assert.assertTrue(map.containsKey(null));
Assert.assertEquals("Y", map.get(null));
for (int i = 0; i < size; i += removeStride)
{
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), map.remove(new CollidingInt(i, shift)));
}
Verify.assertSize(size - size / removeStride + 1, map);
for (int i = 0; i < size; i++)
{
if (i % removeStride != 0)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
Assert.assertTrue(map.containsKey(null));
Assert.assertEquals("Y", map.get(null));
map.remove(null);
Assert.assertFalse(map.containsKey(null));
Assert.assertNull(map.get(null));
}
@Test
public void unifiedMap()
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(i, UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
for (int i = 0; i < size; i++)
{
Assert.assertTrue(map.containsKey(i));
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), map.get(i));
}
for (int i = 0; i < size; i += 2)
{
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), map.remove(i));
}
Verify.assertSize(size / 2, map);
for (int i = 1; i < size; i += 2)
{
Assert.assertTrue(map.containsKey(i));
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), map.get(i));
}
}
@Test
public void unifiedMapClear()
{
UnifiedMapAcceptanceTest.assertUnifiedMapClear(0);
UnifiedMapAcceptanceTest.assertUnifiedMapClear(1);
UnifiedMapAcceptanceTest.assertUnifiedMapClear(2);
UnifiedMapAcceptanceTest.assertUnifiedMapClear(3);
}
private static void assertUnifiedMapClear(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
map.clear();
Verify.assertSize(0, map);
for (int i = 0; i < size; i++)
{
Verify.assertNotContainsKey(new CollidingInt(i, shift), map);
Assert.assertNull(map.get(new CollidingInt(i, shift)));
}
}
@Test
public void unifiedMapForEachEntry()
{
UnifiedMapAcceptanceTest.assertUnifiedMapForEachEntry(0);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachEntry(1);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachEntry(2);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachEntry(3);
}
private static void assertUnifiedMapForEachEntry(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
int[] count = new int[1];
map.forEachKeyValue((key, value) -> {
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(key.getValue()), value);
count[0]++;
});
Assert.assertEquals(size, count[0]);
}
@Test
public void unifiedMapForEachKey()
{
UnifiedMapAcceptanceTest.assertUnifiedMapForEachKey(0);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachKey(1);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachKey(2);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachKey(3);
}
private static void assertUnifiedMapForEachKey(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
List keys = new ArrayList<>(size);
map.forEachKey(keys::add);
Verify.assertSize(size, keys);
Collections.sort(keys);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(new CollidingInt(i, shift), keys.get(i));
}
}
@Test
public void unifiedMapForEachValue()
{
UnifiedMapAcceptanceTest.assertUnifiedMapForEachValue(0);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachValue(1);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachValue(2);
UnifiedMapAcceptanceTest.assertUnifiedMapForEachValue(3);
}
private static void assertUnifiedMapForEachValue(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
List values = new ArrayList<>(size);
map.forEachValue(values::add);
Verify.assertSize(size, values);
Collections.sort(values, UnifiedMapAcceptanceTest.VALUE_COMPARATOR);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(UnifiedMapAcceptanceTest.createVal(i), values.get(i));
}
}
@Test
public void equalsWithNullValue()
{
MutableMap map1 = UnifiedMap.newWithKeysValues(1, null, 2, 2);
MutableMap map2 = UnifiedMap.newWithKeysValues(2, 2, 3, 3);
Assert.assertNotEquals(map1, map2);
}
@Test
public void unifiedMapEqualsAndHashCode()
{
UnifiedMapAcceptanceTest.assertUnifiedMapEqualsAndHashCode(0);
UnifiedMapAcceptanceTest.assertUnifiedMapEqualsAndHashCode(1);
UnifiedMapAcceptanceTest.assertUnifiedMapEqualsAndHashCode(2);
UnifiedMapAcceptanceTest.assertUnifiedMapEqualsAndHashCode(3);
}
private static void assertUnifiedMapEqualsAndHashCode(int shift)
{
MutableMap map1 = UnifiedMap.newMap();
Map map2 = new HashMap<>();
MutableMap map3 = UnifiedMap.newMap();
MutableMap map4 = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map1.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
map2.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
map3.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
map4.put(new CollidingInt(size - i - 1, shift), UnifiedMapAcceptanceTest.createVal(size - i - 1));
}
Assert.assertEquals(map2, map1);
Assert.assertEquals(map1, map2);
Assert.assertEquals(map2.hashCode(), map1.hashCode());
Assert.assertEquals(map1, map3);
Assert.assertEquals(map1.hashCode(), map3.hashCode());
Assert.assertEquals(map2, map4);
Assert.assertEquals(map4, map2);
Assert.assertEquals(map2.hashCode(), map4.hashCode());
Verify.assertSetsEqual(map2.entrySet(), map1.entrySet());
Verify.assertSetsEqual(map1.entrySet(), map2.entrySet());
Assert.assertEquals(map2.entrySet().hashCode(), map1.entrySet().hashCode());
Verify.assertSetsEqual(map1.entrySet(), map3.entrySet());
Assert.assertEquals(map1.entrySet().hashCode(), map3.entrySet().hashCode());
Verify.assertSetsEqual(map2.entrySet(), map4.entrySet());
Verify.assertSetsEqual(map4.entrySet(), map2.entrySet());
Assert.assertEquals(map2.entrySet().hashCode(), map4.entrySet().hashCode());
Verify.assertSetsEqual(map2.keySet(), map1.keySet());
Verify.assertSetsEqual(map1.keySet(), map2.keySet());
Assert.assertEquals(map2.keySet().hashCode(), map1.keySet().hashCode());
Verify.assertSetsEqual(map1.keySet(), map3.keySet());
Assert.assertEquals(map1.keySet().hashCode(), map3.keySet().hashCode());
Verify.assertSetsEqual(map2.keySet(), map4.keySet());
Verify.assertSetsEqual(map4.keySet(), map2.keySet());
Assert.assertEquals(map2.keySet().hashCode(), map4.keySet().hashCode());
}
@Test
public void unifiedMapPutAll()
{
UnifiedMapAcceptanceTest.assertUnifiedMapPutAll(0);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAll(1);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAll(2);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAll(3);
}
private static void assertUnifiedMapPutAll(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
UnifiedMap newMap = UnifiedMap.newMap(size);
newMap.putAll(map);
Verify.assertSize(size, newMap);
for (int i = 0; i < size; i++)
{
Verify.assertContainsKey(new CollidingInt(i, shift), newMap);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), newMap);
}
}
@Test
public void unifiedMapPutAllWithHashMap()
{
UnifiedMapAcceptanceTest.assertUnifiedMapPutAllWithHashMap(0);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAllWithHashMap(1);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAllWithHashMap(2);
UnifiedMapAcceptanceTest.assertUnifiedMapPutAllWithHashMap(3);
}
private static void assertUnifiedMapPutAllWithHashMap(int shift)
{
Map map = new HashMap<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
UnifiedMap newMap = UnifiedMap.newMap(size);
newMap.putAll(map);
Verify.assertSize(size, newMap);
for (int i = 0; i < size; i++)
{
Verify.assertContainsKey(new CollidingInt(i, shift), newMap);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), newMap);
}
}
@Test
public void unifiedMapReplace()
{
UnifiedMapAcceptanceTest.assertUnifiedMapReplace(0);
UnifiedMapAcceptanceTest.assertUnifiedMapReplace(1);
UnifiedMapAcceptanceTest.assertUnifiedMapReplace(2);
UnifiedMapAcceptanceTest.assertUnifiedMapReplace(3);
}
private static void assertUnifiedMapReplace(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), "Y" + i);
}
Verify.assertSize(size, map);
for (int i = 0; i < size; i++)
{
Assert.assertEquals("Y" + i, map.get(new CollidingInt(i, shift)));
}
}
@Test
public void unifiedMapContainsValue()
{
UnifiedMapAcceptanceTest.runUnifiedMapContainsValue(0);
UnifiedMapAcceptanceTest.runUnifiedMapContainsValue(1);
UnifiedMapAcceptanceTest.runUnifiedMapContainsValue(2);
UnifiedMapAcceptanceTest.runUnifiedMapContainsValue(3);
}
private static void runUnifiedMapContainsValue(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 1000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
for (int i = 0; i < size; i++)
{
Assert.assertTrue(map.containsValue(UnifiedMapAcceptanceTest.createVal(i)));
}
}
@Test
public void unifiedMapKeySet()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySet(0);
UnifiedMapAcceptanceTest.runUnifiedMapKeySet(1);
UnifiedMapAcceptanceTest.runUnifiedMapKeySet(2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySet(3);
}
private static void runUnifiedMapKeySet(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
Verify.assertSize(size, keySet);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new CollidingInt(i, shift), keySet);
}
for (int i = 0; i < size; i += 2)
{
Assert.assertTrue(keySet.remove(new CollidingInt(i, shift)));
}
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, keySet);
for (int i = 1; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new CollidingInt(i, shift), keySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapKeySetRetainAll()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRetainAll(0);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRetainAll(1);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRetainAll(2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRetainAll(3);
}
private static void runUnifiedMapKeySetRetainAll(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
List toRetain = new ArrayList<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
if (i % 2 == 0)
{
toRetain.add(new CollidingInt(i, shift));
}
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
Assert.assertTrue(keySet.containsAll(toRetain));
Assert.assertTrue(keySet.retainAll(toRetain));
Assert.assertTrue(keySet.containsAll(toRetain));
Assert.assertFalse(keySet.retainAll(toRetain)); // a second call should not modify the set
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, keySet);
for (int i = 0; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new CollidingInt(i, shift), keySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapKeySetRemoveAll()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRemoveAll(0);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRemoveAll(1);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRemoveAll(2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetRemoveAll(3);
}
private static void runUnifiedMapKeySetRemoveAll(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
List toRemove = new ArrayList<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
if (i % 2 == 0)
{
toRemove.add(new CollidingInt(i, shift));
}
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
Assert.assertTrue(keySet.removeAll(toRemove));
Assert.assertFalse(keySet.removeAll(toRemove)); // a second call should not modify the set
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, keySet);
for (int i = 1; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new CollidingInt(i, shift), keySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapKeySetToArray()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetToArray(0);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetToArray(1);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetToArray(2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetToArray(3);
}
private static void runUnifiedMapKeySetToArray(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
Object[] keys = keySet.toArray();
Arrays.sort(keys);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(new CollidingInt(i, shift), keys[i]);
}
}
@Test
public void unifiedMapKeySetIterator()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIterator(0);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIterator(1);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIterator(2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIterator(3);
}
private static void runUnifiedMapKeySetIterator(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
CollidingInt[] keys = new CollidingInt[size];
int count = 0;
for (CollidingInt collidingInt : keySet)
{
keys[count++] = collidingInt;
}
Arrays.sort(keys);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(new CollidingInt(i, shift), keys[i]);
}
}
@Test
public void unifiedMapKeySetIteratorRemove()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(0, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(1, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(2, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(3, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(0, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(1, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(2, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(3, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(0, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(1, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(2, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemove(3, 4);
}
private static void runUnifiedMapKeySetIteratorRemove(int shift, int removeStride)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
int count = 0;
for (Iterator it = keySet.iterator(); it.hasNext(); )
{
CollidingInt key = it.next();
count++;
if (key.getValue() % removeStride == 0)
{
it.remove();
}
}
Assert.assertEquals(size, count);
for (int i = 0; i < size; i++)
{
if (i % removeStride != 0)
{
Assert.assertTrue("map contains " + i + "for shift " + shift + " and remove stride " + removeStride, map
.containsKey(new CollidingInt(i, shift)));
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
}
@Test
public void unifiedMapKeySetIteratorRemoveFlip()
{
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(0, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(1, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(2, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(3, 2);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(0, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(1, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(2, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(3, 3);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(0, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(1, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(2, 4);
UnifiedMapAcceptanceTest.runUnifiedMapKeySetIteratorRemoveFlip(3, 4);
}
private static void runUnifiedMapKeySetIteratorRemoveFlip(int shift, int removeStride)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set keySet = map.keySet();
int count = 0;
for (Iterator it = keySet.iterator(); it.hasNext(); )
{
CollidingInt key = it.next();
count++;
if (key.getValue() % removeStride != 0)
{
it.remove();
}
}
Assert.assertEquals(size, count);
for (int i = 0; i < size; i++)
{
if (i % removeStride == 0)
{
Assert.assertTrue("map contains " + i + "for shift " + shift + " and remove stride " + removeStride, map
.containsKey(new CollidingInt(i, shift)));
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
}
//entry set tests
@Test
public void unifiedMapEntrySet()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySet(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySet(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySet(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySet(3);
}
private static void runUnifiedMapEntrySet(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set> entrySet = map.entrySet();
Verify.assertSize(size, entrySet);
for (int i = 0; i < size; i++)
{
Verify.assertContains(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entrySet);
}
for (int i = 0; i < size; i += 2)
{
Assert.assertTrue(entrySet.remove(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i))));
}
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, entrySet);
for (int i = 1; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entrySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapEntrySetRetainAll()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRetainAll(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRetainAll(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRetainAll(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRetainAll(3);
}
private static void runUnifiedMapEntrySetRetainAll(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
List toRetain = new ArrayList<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
if (i % 2 == 0)
{
toRetain.add(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)));
}
}
Verify.assertSize(size, map);
Set> entrySet = map.entrySet();
Assert.assertTrue(entrySet.containsAll(toRetain));
Assert.assertTrue(entrySet.retainAll(toRetain));
Assert.assertTrue(entrySet.containsAll(toRetain));
Assert.assertFalse(entrySet.retainAll(toRetain)); // a second call should not modify the set
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, entrySet);
for (int i = 0; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entrySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapEntrySetRemoveAll()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRemoveAll(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRemoveAll(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRemoveAll(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetRemoveAll(3);
}
private static void runUnifiedMapEntrySetRemoveAll(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
List toRemove = new ArrayList<>();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
if (i % 2 == 0)
{
toRemove.add(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)));
}
}
Verify.assertSize(size, map);
Set> entrySet = map.entrySet();
Assert.assertTrue(entrySet.removeAll(toRemove));
Assert.assertFalse(entrySet.removeAll(toRemove)); // a second call should not modify the set
Verify.assertSize(size / 2, map);
Verify.assertSize(size / 2, entrySet);
for (int i = 1; i < size; i += 2)
{
Verify.assertContainsKey(new CollidingInt(i, shift), map);
Verify.assertContains(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entrySet);
Verify.assertContainsKeyValue(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i), map);
}
}
@Test
public void unifiedMapEntrySetToArray()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetToArray(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetToArray(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetToArray(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetToArray(3);
}
private static void runUnifiedMapEntrySetToArray(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set> entrySet = map.entrySet();
Map.Entry[] entries = entrySet.toArray(new Map.Entry[0]);
Arrays.sort(entries, UnifiedMapAcceptanceTest.ENTRY_COMPARATOR);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entries[i]);
}
}
@Test
public void unifiedMapEntrySetIterator()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIterator(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIterator(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIterator(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIterator(3);
}
private static void runUnifiedMapEntrySetIterator(int shift)
{
UnifiedMap map = UnifiedMap.newMap();
int size = 100000;
for (int i = 0; i < size; i++)
{
map.put(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i));
}
Verify.assertSize(size, map);
Set> entrySet = map.entrySet();
Map.Entry[] entries = new Map.Entry[size];
int count = 0;
for (Map.Entry collidingIntStringEntry : entrySet)
{
entries[count++] = collidingIntStringEntry;
}
Arrays.sort(entries, UnifiedMapAcceptanceTest.ENTRY_COMPARATOR);
for (int i = 0; i < size; i++)
{
Assert.assertEquals(new Entry(new CollidingInt(i, shift), UnifiedMapAcceptanceTest.createVal(i)), entries[i]);
}
}
@Test
public void unifiedMapEntrySetIteratorSetValue()
{
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIteratorSetValue(0);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIteratorSetValue(1);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIteratorSetValue(2);
UnifiedMapAcceptanceTest.runUnifiedMapEntrySetIteratorSetValue(3);
}
private static void runUnifiedMapEntrySetIteratorSetValue(int shift)
{
UnifiedMap