forked from Speiger/Primitive-Collections
181 lines
7.1 KiB
Java
181 lines
7.1 KiB
Java
package speiger.src.collections.ints.base;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import java.util.stream.IntStream;
|
|
|
|
import org.junit.Assert;
|
|
import org.junit.Test;
|
|
|
|
import speiger.src.collections.ints.collections.IntCollection;
|
|
import speiger.src.collections.ints.utils.IntArrays;
|
|
import speiger.src.collections.ints.utils.IntCollections;
|
|
import speiger.src.collections.ints.utils.IntCollections.SynchronizedCollection;
|
|
import speiger.src.collections.ints.utils.IntCollections.UnmodifiableCollection;
|
|
import speiger.src.collections.objects.lists.ObjectArrayList;
|
|
import speiger.src.collections.tests.CollectionTest;
|
|
|
|
@SuppressWarnings("javadoc")
|
|
public abstract class BaseIntCollectionTest extends BaseIntIterableTest
|
|
{
|
|
protected static final int[] ADD_ARRAY = new int[]{3212, -12, 423, -182, -4912};
|
|
protected static final int[] BULK_ADD_ARRAY = IntStream.range(200, 500).toArray();
|
|
protected static final int[] CONTAINS_ARRAY = new int[]{23, 45, 63, 89, 32};
|
|
|
|
@Override
|
|
protected abstract IntCollection create(int[] data);
|
|
|
|
protected EnumSet<CollectionTest> getValidCollectionTests() { return EnumSet.allOf(CollectionTest.class); }
|
|
|
|
@Test
|
|
public void testAdd() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.ADD)) return;
|
|
IntCollection collection = create(EMPTY_ARRAY);
|
|
Assert.assertTrue(collection.isEmpty());
|
|
collection.add(2012);
|
|
Assert.assertFalse(collection.isEmpty());
|
|
Assert.assertTrue(collection.contains(2012));
|
|
}
|
|
|
|
@Test
|
|
public void testAddAll() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.ADD_ALL)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertEquals(TEST_ARRAY.length, collection.size());
|
|
collection.addAll(create(ADD_ARRAY));
|
|
Assert.assertEquals(TEST_ARRAY.length + ADD_ARRAY.length, collection.size());
|
|
collection = create(TEST_ARRAY);
|
|
Assert.assertEquals(TEST_ARRAY.length, collection.size());
|
|
collection.addAll(create(BULK_ADD_ARRAY));
|
|
Assert.assertEquals(TEST_ARRAY.length + BULK_ADD_ARRAY.length, collection.size());
|
|
// Testing if adding via non Type Specific work like they should
|
|
List<Integer> wrapper = new ObjectArrayList<>(create(ADD_ARRAY));
|
|
Assert.assertNotNull(create(ADD_ARRAY).addAll(wrapper));
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings("deprecation")
|
|
public void testContains() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.CONTAINS)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.contains(50));
|
|
Assert.assertFalse(collection.contains(5120));
|
|
Assert.assertTrue(collection.contains(Integer.valueOf(50)));
|
|
}
|
|
|
|
@Test
|
|
public void testContainsAll() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.CONTAINS_ALL)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.containsAll(create(CONTAINS_ARRAY)));
|
|
Assert.assertFalse(collection.containsAll(create(ADD_ARRAY)));
|
|
Assert.assertTrue(collection.containsAll(Arrays.asList(IntArrays.wrap(CONTAINS_ARRAY))));
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings("deprecation")
|
|
public void testContainsAny() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.CONTAINS_ANY)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.containsAny(create(CONTAINS_ARRAY)));
|
|
Assert.assertFalse(collection.containsAny(create(ADD_ARRAY)));
|
|
Assert.assertTrue(collection.containsAny(Arrays.asList(IntArrays.wrap(CONTAINS_ARRAY))));
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings("deprecation")
|
|
public void testRemove() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.REMOVE)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.remInt(50));
|
|
Assert.assertFalse(collection.remInt(50));
|
|
Assert.assertTrue(collection.remove(Integer.valueOf(75)));
|
|
}
|
|
|
|
@Test
|
|
@SuppressWarnings("deprecation")
|
|
public void testRemoveIf() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.REMOVE_IF)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.remIf(T -> T != 25));
|
|
Assert.assertFalse(collection.remIf(T -> T != 25));
|
|
Assert.assertEquals(1, collection.size());
|
|
collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.removeIf(T -> T.intValue() != 25));
|
|
Assert.assertFalse(collection.removeIf(T -> T.intValue() != 25));
|
|
Assert.assertEquals(1, collection.size());
|
|
}
|
|
|
|
@Test
|
|
public void testRemoveAll() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.REMOVE_ALL)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertTrue(collection.removeAll(create(CONTAINS_ARRAY)));
|
|
Assert.assertFalse(collection.removeAll(create(CONTAINS_ARRAY)));
|
|
collection = create(TEST_ARRAY);
|
|
Assert.assertFalse(collection.removeAll(Arrays.asList(IntArrays.wrap(ADD_ARRAY))));
|
|
Assert.assertTrue(collection.removeAll(Arrays.asList(IntArrays.wrap(CONTAINS_ARRAY))));
|
|
}
|
|
|
|
@Test
|
|
public void testRetainAll() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.RETAIN_ALL)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
IntCollection retained = create(CONTAINS_ARRAY);
|
|
Assert.assertTrue(collection.retainAll(retained));
|
|
Assert.assertFalse(collection.retainAll(retained));
|
|
Assert.assertEquals(CONTAINS_ARRAY.length, collection.size());
|
|
int[] retainedArray = retained.toIntArray();
|
|
int[] collectionArray = collection.toIntArray();
|
|
IntArrays.stableSort(retainedArray);
|
|
IntArrays.stableSort(collectionArray);
|
|
Assert.assertArrayEquals(retainedArray, collectionArray);
|
|
collection.retainAll(IntCollections.EMPTY);
|
|
Assert.assertTrue(collection.isEmpty());
|
|
}
|
|
|
|
@Test
|
|
public void testToArray() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.TO_ARRAY)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
int[] array = collection.toIntArray();
|
|
IntArrays.stableSort(array);
|
|
Assert.assertArrayEquals(array, TEST_ARRAY);
|
|
int[] other = collection.toIntArray(new int[collection.size()]);
|
|
IntArrays.stableSort(other);
|
|
Assert.assertArrayEquals(other, TEST_ARRAY);
|
|
other = IntArrays.unwrap(collection.toArray(new Integer[collection.size()]));
|
|
IntArrays.stableSort(other);
|
|
Assert.assertArrayEquals(other, TEST_ARRAY);
|
|
}
|
|
|
|
@Test
|
|
public void testClear() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.CLEAR)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
Assert.assertFalse(collection.isEmpty());
|
|
collection.clear();
|
|
Assert.assertTrue(collection.isEmpty());
|
|
}
|
|
|
|
@Test
|
|
public void testWrapper() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.WRAPPER)) return;
|
|
IntCollection collection = create(TEST_ARRAY);
|
|
collection = IntCollections.synchronize(collection);
|
|
Assert.assertTrue(collection instanceof SynchronizedCollection);
|
|
collection = IntCollections.unmodifiable(collection);
|
|
Assert.assertTrue(collection instanceof UnmodifiableCollection);
|
|
}
|
|
|
|
@Test
|
|
public void testToString() {
|
|
if(!getValidCollectionTests().contains(CollectionTest.TO_STRING)) return;
|
|
String base = Arrays.toString(BULK_ADD_ARRAY);
|
|
IntCollection collection = create(BULK_ADD_ARRAY);
|
|
Assert.assertEquals(base, collection.toString());
|
|
Assert.assertEquals(base, IntCollections.synchronize(collection).toString());
|
|
Assert.assertEquals(base, IntCollections.unmodifiable(collection).toString());
|
|
}
|
|
} |