Refactor of the Project on Github.
-Added: Better System to decide what code should be generated. -Added: Unit Tests are now included in the main branch. -Added: Automatic System to test the main branch and ensure that tests work. -Added: Pull Requests now run tests too.
This commit is contained in:
+314
@@ -0,0 +1,314 @@
|
||||
package speiger.src.testers.PACKAGE.impl;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
|
||||
import org.junit.Ignore;
|
||||
|
||||
import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
|
||||
import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
|
||||
import speiger.src.collections.PACKAGE.lists.COPY_ON_WRITE_LIST;
|
||||
import speiger.src.collections.PACKAGE.lists.IMMUTABLE_LIST;
|
||||
#if !TYPE_BOOLEAN
|
||||
import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.HASH_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.IMMUTABLE_HASH_SET;
|
||||
import speiger.src.collections.PACKAGE.utils.STRATEGY;
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
import speiger.src.collections.objects.utils.StringSortTest;
|
||||
#endif
|
||||
import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionConstructorTester;
|
||||
|
||||
@Ignore
|
||||
@SuppressWarnings("javadoc")
|
||||
public class COLLECTION_CONSTRUCTOR_TESTS
|
||||
{
|
||||
public static class ArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public ArrayList() {
|
||||
setSimpleConstructor(ARRAY_LIST::new);
|
||||
setSizeConstructor(T -> new ARRAY_LISTBRACES(T));
|
||||
setPArrayConstructor(T -> new ARRAY_LISTBRACES(T));
|
||||
setPCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
|
||||
setCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public LinkedList() {
|
||||
setSimpleConstructor(LINKED_LIST::new);
|
||||
setPArrayConstructor(T -> new LINKED_LISTBRACES(T));
|
||||
setPCollectionConstructor(T -> new LINKED_LISTBRACES(T));
|
||||
setCollectionConstructor(T -> new LINKED_LISTBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class CopyOnWriteArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public CopyOnWriteArrayList() {
|
||||
setSimpleConstructor(COPY_ON_WRITE_LIST::new);
|
||||
setPArrayConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
|
||||
setPCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
|
||||
setCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ImmutableList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public ImmutableList() {
|
||||
setPArrayConstructor(T -> new IMMUTABLE_LISTBRACES(T));
|
||||
setPCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
|
||||
setCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !TYPE_BOOLEAN
|
||||
public static class HashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public HashSet() {
|
||||
setSimpleConstructor(HASH_SET::new);
|
||||
setSizeConstructor(T -> new HASH_SETBRACES(T));
|
||||
setPArrayConstructor(T -> new HASH_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new HASH_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new HASH_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public LinkedHashSet() {
|
||||
setSimpleConstructor(LINKED_HASH_SET::new);
|
||||
setSizeConstructor(T -> new LINKED_HASH_SETBRACES(T));
|
||||
setPArrayConstructor(T -> new LINKED_HASH_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class CustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public CustomHashSet() {
|
||||
setSimpleConstructor(() -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setPArrayConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setPCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedCustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public LinkedCustomHashSet() {
|
||||
setSimpleConstructor(() -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setPArrayConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setPCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
setCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ImmutableHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public ImmutableHashSet() {
|
||||
setPArrayConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ArraySet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public ArraySet() {
|
||||
setSimpleConstructor(ARRAY_SET::new);
|
||||
setSizeConstructor(T -> new ARRAY_SETBRACES(T));
|
||||
setPArrayConstructor(T -> new ARRAY_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new ARRAY_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new ARRAY_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public RBTreeSet() {
|
||||
setSimpleConstructor(RB_TREE_SET::new);
|
||||
setPArrayConstructor(T -> new RB_TREE_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public AVLTreeSet() {
|
||||
setSimpleConstructor(AVL_TREE_SET::new);
|
||||
setPArrayConstructor(T -> new AVL_TREE_SETBRACES(T));
|
||||
setPCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
|
||||
setCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public RBTreeSetComparator() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> new RB_TREE_SET<String>(Comparator.naturalOrder()));
|
||||
setPArrayConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
setPCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
setCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> new RB_TREE_SET(CLASS_TYPE::compare));
|
||||
setPArrayConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
|
||||
setPCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
|
||||
setCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
|
||||
{
|
||||
@SuppressWarnings("deprecation")
|
||||
public AVLTreeSetComparator() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> new AVL_TREE_SET<String>(Comparator.naturalOrder()));
|
||||
setPArrayConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
setPCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
setCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> new AVL_TREE_SET(CLASS_TYPE::compare));
|
||||
setPArrayConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
|
||||
setPCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
|
||||
setCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
|
||||
static final HashStrategy INSTANCE = new HashStrategy();
|
||||
@Override
|
||||
public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
|
||||
@Override
|
||||
public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
|
||||
}
|
||||
#endif
|
||||
}
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
package speiger.src.testers.PACKAGE.impl;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.function.Function;
|
||||
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
|
||||
#if TYPE_OBJECT
|
||||
import speiger.src.collections.objects.utils.ObjectArrays;
|
||||
#endif
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE implements TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper;
|
||||
#if TYPE_OBJECT
|
||||
KEY_TYPE[] keys;
|
||||
#endif
|
||||
|
||||
public SIMPLE_QUEUE_TEST_GENERATOR(Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper) {
|
||||
this.mapper = mapper;
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
public SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE setElements(KEY_TYPE...keys) {
|
||||
this.keys = keys;
|
||||
return this;
|
||||
}
|
||||
|
||||
#endif
|
||||
public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
|
||||
#if TYPE_BOOLEAN
|
||||
return new SAMPLE_ELEMENTS(true, false, true, false, true);
|
||||
#else if TYPE_BYTE
|
||||
return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
|
||||
#else if TYPE_SHORT
|
||||
return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
|
||||
#else if TYPE_CHAR
|
||||
return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
|
||||
#else if TYPE_OBJECT
|
||||
return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
|
||||
#else
|
||||
return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
return mapper.apply(elements);
|
||||
}
|
||||
|
||||
public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
|
||||
KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
|
||||
int i = 0;
|
||||
for (Object e : elements) {
|
||||
array[i++] = CLASS_TO_KEY(e);
|
||||
}
|
||||
return mapper.apply(array);
|
||||
}
|
||||
|
||||
#else
|
||||
public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
|
||||
T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
|
||||
int i = 0;
|
||||
for (Object e : elements) {
|
||||
array[i++] = CLASS_TO_KEY(e);
|
||||
}
|
||||
return mapper.apply(array);
|
||||
}
|
||||
|
||||
#endif
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
}
|
||||
+221
@@ -0,0 +1,221 @@
|
||||
package speiger.src.testers.PACKAGE.impl;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.function.Function;
|
||||
|
||||
import speiger.src.collections.PACKAGE.collections.COLLECTION;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
#if !TYPE_BOOLEAN
|
||||
import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.SET;
|
||||
import speiger.src.collections.PACKAGE.sets.SORTED_SET;
|
||||
#if TYPE_OBJECT
|
||||
import speiger.src.collections.objects.utils.ObjectArrays;
|
||||
#endif
|
||||
#endif
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
|
||||
#if !TYPE_BOOLEAN
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
|
||||
#endif
|
||||
import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E extends COLLECTION KEY_GENERIC_TYPE> {
|
||||
Function<KEY_TYPE[], E> mapper;
|
||||
#if TYPE_OBJECT
|
||||
KEY_TYPE[] keys;
|
||||
#endif
|
||||
|
||||
public SIMPLE_TEST_GENERATOR(Function<KEY_TYPE[], E> mapper) {
|
||||
this.mapper = mapper;
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
public SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E> setElements(KEY_TYPE...keys) {
|
||||
this.keys = keys;
|
||||
return this;
|
||||
}
|
||||
|
||||
#endif
|
||||
public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
|
||||
#if TYPE_BOOLEAN
|
||||
return new SAMPLE_ELEMENTS(true, false, true, false, true);
|
||||
#else if TYPE_BYTE
|
||||
return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
|
||||
#else if TYPE_SHORT
|
||||
return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
|
||||
#else if TYPE_CHAR
|
||||
return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
|
||||
#else if TYPE_OBJECT
|
||||
return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
|
||||
#else
|
||||
return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
public E create(KEY_TYPE... elements) {
|
||||
return mapper.apply(elements);
|
||||
}
|
||||
|
||||
public E create(Object... elements) {
|
||||
KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
|
||||
int i = 0;
|
||||
for (Object e : elements) {
|
||||
array[i++] = CLASS_TO_KEY(e);
|
||||
}
|
||||
return mapper.apply(array);
|
||||
}
|
||||
|
||||
#else
|
||||
public E create(Object... elements) {
|
||||
T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
|
||||
int i = 0;
|
||||
for (Object e : elements) {
|
||||
array[i++] = CLASS_TO_KEY(e);
|
||||
}
|
||||
return mapper.apply(array);
|
||||
}
|
||||
|
||||
#endif
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public static class Collections KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<COLLECTION KEY_GENERIC_TYPE> implements TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public Collections(Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
public static class Lists KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<LIST KEY_GENERIC_TYPE> implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public Lists(Function<KEY_TYPE[], LIST KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
#if !TYPE_BOOLEAN
|
||||
public static class Sets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SET KEY_GENERIC_TYPE> implements TEST_SET_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public Sets(Function<KEY_TYPE[], SET KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
public static class OrderedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<ORDERED_SET KEY_GENERIC_TYPE> implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public OrderedSets(Function<KEY_TYPE[], ORDERED_SET KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
public static class SortedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SORTED_SET KEY_GENERIC_TYPE> implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public SortedSets(Function<KEY_TYPE[], SORTED_SET KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
insertionOrder.sort(null);
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
insertionOrder.sort(null);
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
#if TYPE_CHAR
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return '_'; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return '`'; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return 'f'; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return 'g'; }
|
||||
#else if TYPE_OBJECT
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return keys[5]; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return keys[6]; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
|
||||
#else
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return -2; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return -1; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return 5; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return 6; }
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class NavigableSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<NAVIGABLE_SET KEY_GENERIC_TYPE> implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
public NavigableSets(Function<KEY_TYPE[], NAVIGABLE_SET KEY_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
insertionOrder.sort(null);
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
insertionOrder.sort(null);
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
#if TYPE_CHAR
|
||||
public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() { return new SAMPLE_ELEMENTS('a', 'b', 'c', 'd', 'e'); }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return '_'; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return '`'; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return 'f'; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return 'g'; }
|
||||
#else if TYPE_OBJECT
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return keys[5]; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return keys[6]; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
|
||||
#else
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() { return -2; }
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() { return -1; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() { return 5; }
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() { return 6; }
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
+173
@@ -0,0 +1,173 @@
|
||||
package speiger.src.testers.PACKAGE.impl;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Comparator;
|
||||
#endif
|
||||
import java.util.List;
|
||||
|
||||
import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
|
||||
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.SORTED_SET;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
final Bound to;
|
||||
final Bound from;
|
||||
final KEY_TYPE firstInclusive;
|
||||
final KEY_TYPE lastInclusive;
|
||||
private final COMPARATOR KEY_GENERIC_TYPE comparator;
|
||||
private final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate;
|
||||
|
||||
public SUB_SORTED_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
|
||||
this.to = to;
|
||||
this.from = from;
|
||||
this.delegate = delegate;
|
||||
|
||||
SORTED_SET KEY_GENERIC_TYPE emptySet = delegate.create(NEW_KEY_ARRAY(0));
|
||||
comparator = emptySet.comparator();
|
||||
|
||||
SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples = delegate.getSamples();
|
||||
LIST KEY_GENERIC_TYPE samplesList = new ARRAY_LISTBRACES(samples.asList());
|
||||
samplesList.sort(comparator);
|
||||
firstInclusive = samplesList.GET_KEY(0);
|
||||
lastInclusive = samplesList.GET_KEY(samplesList.size() - 1);
|
||||
}
|
||||
|
||||
public final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE getInnerGenerator() {
|
||||
return delegate;
|
||||
}
|
||||
|
||||
public final Bound getTo() {
|
||||
return to;
|
||||
}
|
||||
|
||||
public final Bound getFrom() {
|
||||
return from;
|
||||
}
|
||||
|
||||
SORTED_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE set, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
|
||||
if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
|
||||
return set.headSet(lastExclusive);
|
||||
} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
|
||||
return set.tailSet(firstInclusive);
|
||||
} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
|
||||
return set.subSet(firstInclusive, lastExclusive);
|
||||
} else {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
|
||||
return delegate.getSamples();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
return delegate.order(insertionOrder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
return delegate.order(insertionOrder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE create(KEY_OBJECT_TYPE... elements) {
|
||||
#if TYPE_OBJECT
|
||||
LIST KEY_GENERIC_TYPE normalValues = (LIST KEY_GENERIC_TYPE)ARRAY_LIST.wrap(elements);
|
||||
#else
|
||||
LIST KEY_GENERIC_TYPE normalValues = ARRAY_LIST.wrap(elements);
|
||||
#endif
|
||||
LIST KEY_GENERIC_TYPE extremeValues = new ARRAY_LISTBRACES();
|
||||
KEY_TYPE firstExclusive = delegate.belowSamplesGreater();
|
||||
KEY_TYPE lastExclusive = delegate.aboveSamplesLesser();
|
||||
if (from != Bound.NO_BOUND) {
|
||||
extremeValues.add(delegate.belowSamplesLesser());
|
||||
extremeValues.add(delegate.belowSamplesGreater());
|
||||
}
|
||||
if (to != Bound.NO_BOUND) {
|
||||
extremeValues.add(delegate.aboveSamplesLesser());
|
||||
extremeValues.add(delegate.aboveSamplesGreater());
|
||||
}
|
||||
LIST KEY_GENERIC_TYPE allEntries = new ARRAY_LISTBRACES();
|
||||
allEntries.addAll(extremeValues);
|
||||
allEntries.addAll(normalValues);
|
||||
SORTED_SET KEY_GENERIC_TYPE set = delegate.create(allEntries.toArray());
|
||||
|
||||
return createSubSet(set, firstExclusive, lastExclusive);
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
|
||||
int i = 0;
|
||||
for (Object e : elements) {
|
||||
array[i++] = CLASS_TO_KEY(e);
|
||||
}
|
||||
return create(array);
|
||||
}
|
||||
|
||||
#endif
|
||||
public static final class SUB_NAVIGABLE_SET_CLASS_GENERATOR KEY_GENERIC_TYPE extends SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
|
||||
public SUB_NAVIGABLE_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
|
||||
super(delegate, to, from);
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
|
||||
}
|
||||
|
||||
@Override
|
||||
NAVIGABLE_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE sortedSet, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
|
||||
NAVIGABLE_SET KEY_GENERIC_TYPE set = (NAVIGABLE_SET KEY_GENERIC_TYPE) sortedSet;
|
||||
if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) return set.headSet(lastInclusive, true);
|
||||
else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) return set.tailSet(firstExclusive, false);
|
||||
else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) return set.subSet(firstExclusive, false, lastExclusive, false);
|
||||
else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstExclusive, false, lastInclusive, true);
|
||||
else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstInclusive, true, lastInclusive, true);
|
||||
return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.createSubSet(set, firstExclusive, lastExclusive);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
+550
@@ -0,0 +1,550 @@
|
||||
package speiger.src.testers.PACKAGE.impl.maps;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
#if VALUE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
|
||||
import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
|
||||
import com.google.common.collect.testing.OneSizeTestContainerGenerator;
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.sets.SET;
|
||||
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.sets.SORTED_SET;
|
||||
import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
|
||||
#endif
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
|
||||
#endif
|
||||
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
|
||||
#if !VALUE_OBJECT && !SAME_TYPE
|
||||
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERABLE;
|
||||
import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST;
|
||||
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_COMPARATOR;
|
||||
#endif
|
||||
import speiger.src.testers.VALUE_PACKAGE.generators.VALUE_TEST_COLLECTION_GENERATOR;
|
||||
#if !VALUE_OBJECT && !SAME_TYPE
|
||||
import speiger.src.testers.VALUE_PACKAGE.utils.VALUE_SAMPLE_ELEMENTS;
|
||||
#endif
|
||||
import speiger.src.collections.objects.collections.ObjectIterable;
|
||||
import speiger.src.collections.objects.lists.ObjectArrayList;
|
||||
import speiger.src.collections.objects.lists.ObjectList;
|
||||
import speiger.src.collections.objects.sets.ObjectSet;
|
||||
import speiger.src.collections.objects.sets.ObjectOrderedSet;
|
||||
import speiger.src.collections.objects.utils.ObjectIterators;
|
||||
import speiger.src.collections.objects.utils.ObjectLists;
|
||||
import speiger.src.testers.objects.generators.TestObjectSetGenerator;
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
|
||||
#endif
|
||||
import speiger.src.testers.objects.utils.ObjectSamples;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class DERIVED_MAP_GENERATORS {
|
||||
public static class NavigableMapGenerator KEY_VALUE_GENERIC_TYPE extends SortedMapGenerator KEY_VALUE_GENERIC_TYPE {
|
||||
public NavigableMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent, Bound to, Bound from) {
|
||||
super(parent, to, from);
|
||||
}
|
||||
|
||||
@Override
|
||||
NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE createSubMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE sortedMap, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
|
||||
NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE map = (NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE) sortedMap;
|
||||
if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
|
||||
return map.headMap(lastInclusive, true);
|
||||
} else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
|
||||
return map.tailMap(firstExclusive, false);
|
||||
} else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
|
||||
return map.subMap(firstExclusive, false, lastExclusive, false);
|
||||
} else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
|
||||
return map.subMap(firstExclusive, false, lastInclusive, true);
|
||||
} else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
|
||||
return map.subMap(firstInclusive, true, lastInclusive, true);
|
||||
} else {
|
||||
return (NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE) super.createSubMap(map, firstExclusive, lastExclusive);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static class SortedMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE {
|
||||
TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
|
||||
Bound to;
|
||||
Bound from;
|
||||
KEY_TYPE firstInclusive;
|
||||
KEY_TYPE lastInclusive;
|
||||
Comparator<Entry KEY_VALUE_GENERIC_TYPE> entryComparator;
|
||||
|
||||
public SortedMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent, Bound to, Bound from) {
|
||||
super(parent);
|
||||
this.parent = parent;
|
||||
this.to = to;
|
||||
this.from = from;
|
||||
SORTED_MAP KEY_VALUE_GENERIC_TYPE map = parent.create();
|
||||
entryComparator = DERIVED_MAP_GENERATORS.entryComparator(map.comparator());
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> samples = parent.getSamples().asList();
|
||||
samples.sort(entryComparator);
|
||||
firstInclusive = samples.get(0).ENTRY_KEY();
|
||||
lastInclusive = samples.get(samples.size() - 1).ENTRY_KEY();
|
||||
}
|
||||
|
||||
@Override
|
||||
public SORTED_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
|
||||
if (from != Bound.NO_BOUND) {
|
||||
entries.add(parent.belowSamplesLesser());
|
||||
entries.add(parent.belowSamplesGreater());
|
||||
}
|
||||
if (to != Bound.NO_BOUND) {
|
||||
entries.add(parent.aboveSamplesLesser());
|
||||
entries.add(parent.aboveSamplesGreater());
|
||||
}
|
||||
entries.addAll(elements);
|
||||
return createSubMap(parent.create(entries.toArray(Entry[]::new)), parent.belowSamplesGreater().ENTRY_KEY(), parent.aboveSamplesLesser().ENTRY_KEY());
|
||||
}
|
||||
|
||||
SORTED_MAP KEY_VALUE_GENERIC_TYPE createSubMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE map, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
|
||||
if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
|
||||
return map.headMap(lastExclusive);
|
||||
} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
|
||||
return map.tailMap(firstInclusive);
|
||||
} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
|
||||
return map.subMap(firstInclusive, lastExclusive);
|
||||
} else {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
public static class DescendingTestMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
|
||||
|
||||
public DescendingTestMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
|
||||
super(parent);
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
|
||||
return ((NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE)parent.create(elements)).descendingMap();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
|
||||
ObjectList<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> values = ObjectIterators.pour(ObjectIterators.wrap(parent.order(insertionOrder).iterator()));
|
||||
ObjectLists.reverse(values);
|
||||
return values;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> values = parent.order(insertionOrder).pourAsList();
|
||||
ObjectLists.reverse(values);
|
||||
return values;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() {
|
||||
return parent.aboveSamplesGreater();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() {
|
||||
return parent.aboveSamplesLesser();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() {
|
||||
return parent.belowSamplesGreater();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() {
|
||||
return parent.belowSamplesLesser();
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
|
||||
|
||||
public MapGenerator(TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
|
||||
return parent.order(insertionOrder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectSamples<Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
|
||||
return parent.getSamples();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
return parent.order(insertionOrder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
|
||||
return parent.create(elements);
|
||||
}
|
||||
}
|
||||
|
||||
public static GENERIC_KEY_VALUE_BRACES TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
if(inner.getInnerGenerator() instanceof TEST_ORDERED_MAP_GENERATOR) {
|
||||
ObjectSet<Entry KEY_VALUE_GENERIC_TYPE> set = ((TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().ENTRY_SET();
|
||||
if(set instanceof ObjectOrderedSet) return new OrderedMapEntrySetGeneratorKV_BRACES(inner);
|
||||
}
|
||||
return new MapEntrySetGeneratorKV_BRACES(inner);
|
||||
}
|
||||
|
||||
public static class OrderedMapEntrySetGenerator KEY_VALUE_GENERIC_TYPE extends MapEntrySetGenerator KEY_VALUE_GENERIC_TYPE implements TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
|
||||
|
||||
public OrderedMapEntrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
super(inner);
|
||||
}
|
||||
|
||||
public ObjectOrderedSet<Entry KEY_VALUE_GENERIC_TYPE> create(Object... elements) {
|
||||
return (ObjectOrderedSet<Entry KEY_VALUE_GENERIC_TYPE>)super.create(elements);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapEntrySetGenerator KEY_VALUE_GENERIC_TYPE implements TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
|
||||
TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
|
||||
|
||||
public MapEntrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectSamples<Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
|
||||
return generator.getSamples();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
return generator.order(insertionOrder);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<Entry KEY_VALUE_GENERIC_TYPE> order(List<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
return generator.order(new ObjectArrayList<Entry KEY_VALUE_GENERIC_TYPE>(insertionOrder));
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entry KEY_VALUE_GENERIC_TYPE[] createArray(int length) {
|
||||
return new Entry[length];
|
||||
}
|
||||
|
||||
@Override
|
||||
public ObjectSet<Entry KEY_VALUE_GENERIC_TYPE> create(Object... elements) {
|
||||
return generator.create(elements).ENTRY_SET();
|
||||
}
|
||||
}
|
||||
|
||||
public static GENERIC_KEY_VALUE_BRACES TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
if (inner.getInnerGenerator() instanceof TEST_SORTED_MAP_GENERATOR) {
|
||||
SET KEY_GENERIC_TYPE set = ((TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().keySet();
|
||||
if(set instanceof NAVIGABLE_SET) return new MapNavigableKeySetGeneratorKV_BRACES(inner);
|
||||
if(set instanceof SORTED_SET) return new MapSortedKeySetGeneratorKV_BRACES(inner);
|
||||
}
|
||||
if(inner.getInnerGenerator() instanceof TEST_ORDERED_MAP_GENERATOR) {
|
||||
SET KEY_GENERIC_TYPE set = ((TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().keySet();
|
||||
if(set instanceof ORDERED_SET) return new MapOrderedKeySetGeneratorKV_BRACES(inner);
|
||||
}
|
||||
return new MapKeySetGeneratorKV_BRACES(inner);
|
||||
}
|
||||
|
||||
public static class MapNavigableKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapSortedKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
|
||||
public MapNavigableKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
super(inner);
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
return (NAVIGABLE_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
return (NAVIGABLE_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapSortedKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE {
|
||||
TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
|
||||
|
||||
public MapSortedKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
super(inner);
|
||||
generator = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
return (SORTED_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
return (SORTED_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesLesser() {
|
||||
return generator.belowSamplesLesser().ENTRY_KEY();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE belowSamplesGreater() {
|
||||
return generator.belowSamplesGreater().ENTRY_KEY();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesLesser() {
|
||||
return generator.aboveSamplesLesser().ENTRY_KEY();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE aboveSamplesGreater() {
|
||||
return generator.aboveSamplesGreater().ENTRY_KEY();
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapOrderedKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE {
|
||||
|
||||
public MapOrderedKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
super(inner);
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
return (ORDERED_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public ORDERED_SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
return (ORDERED_SET KEY_GENERIC_TYPE) super.create(elements);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SET_GENERATOR KEY_GENERIC_TYPE {
|
||||
TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
|
||||
SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples;
|
||||
|
||||
public MapKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
|
||||
ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = generator.getSamples();
|
||||
this.samples = new SAMPLE_ELEMENTSBRACES(samples.e0().ENTRY_KEY(), samples.e1().ENTRY_KEY(), samples.e2().ENTRY_KEY(), samples.e3().ENTRY_KEY(), samples.e4().ENTRY_KEY());
|
||||
}
|
||||
|
||||
@Override
|
||||
public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
|
||||
return samples;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
|
||||
VALUE_TYPE value = generator.getSamples().e0().ENTRY_VALUE();
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
|
||||
for (KEY_TYPE key : insertionOrder) {
|
||||
entries.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(key, value));
|
||||
}
|
||||
LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.order(entries)) {
|
||||
list.add(entry.ENTRY_KEY());
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
|
||||
VALUE_TYPE value = generator.getSamples().e0().ENTRY_VALUE();
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
|
||||
for (KEY_TYPE key : insertionOrder) {
|
||||
entries.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(key, value));
|
||||
}
|
||||
LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.order(entries)) {
|
||||
list.add(entry.ENTRY_KEY());
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
|
||||
Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
|
||||
int index = 0;
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
|
||||
result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(elements[index++], entry.ENTRY_VALUE());
|
||||
}
|
||||
return generator.create(result).keySet();
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public SET KEY_GENERIC_TYPE create(Object... elements) {
|
||||
Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
|
||||
int index = 0;
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
|
||||
result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES((CLASS_TYPE) elements[index++], entry.getValue());
|
||||
}
|
||||
return generator.create(result).keySet();
|
||||
}
|
||||
}
|
||||
|
||||
public static class MapValueCollectionGenerator KEY_VALUE_GENERIC_TYPE implements VALUE_TEST_COLLECTION_GENERATOR VALUE_GENERIC_TYPE {
|
||||
TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
|
||||
VALUE_SAMPLE_ELEMENTS VALUE_GENERIC_TYPE samples;
|
||||
|
||||
public MapValueCollectionGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
|
||||
generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
|
||||
ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = generator.getSamples();
|
||||
this.samples = new VALUE_SAMPLE_ELEMENTSVALUE_BRACES(samples.e0().ENTRY_VALUE(), samples.e1().ENTRY_VALUE(), samples.e2().ENTRY_VALUE(), samples.e3().ENTRY_VALUE(), samples.e4().ENTRY_VALUE());
|
||||
}
|
||||
|
||||
@Override
|
||||
public VALUE_SAMPLE_ELEMENTS VALUE_GENERIC_TYPE getSamples() {
|
||||
return samples;
|
||||
}
|
||||
|
||||
@Override
|
||||
public VALUE_ITERABLE VALUE_GENERIC_TYPE order(VALUE_LIST VALUE_GENERIC_TYPE insertionOrder) {
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> list = generator.order(generator.getSamples().asList()).pourAsList();
|
||||
#if VALUE_OBJECT
|
||||
insertionOrder.sort(new Comparator<VALUE_TYPE>() {
|
||||
#else
|
||||
insertionOrder.sort(new VALUE_COMPARATOR VALUE_GENERIC_TYPE() {
|
||||
#endif
|
||||
@Override
|
||||
public int compare(VALUE_TYPE key, VALUE_TYPE value) {
|
||||
return Integer.signum(indexOf(key) - indexOf(value));
|
||||
}
|
||||
|
||||
protected int indexOf(VALUE_TYPE entry) {
|
||||
for(int i = 0,m=list.size();i<m;i++) {
|
||||
if(VALUE_EQUALS(list.get(i).ENTRY_VALUE(), entry)) return i;
|
||||
}
|
||||
throw new IllegalArgumentException("MAP.values generator can order only sample values");
|
||||
}
|
||||
});
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterable<CLASS_VALUE_TYPE> order(List<CLASS_VALUE_TYPE> insertionOrder) {
|
||||
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> list = generator.order(generator.getSamples().asList()).pourAsList();
|
||||
insertionOrder.sort(new Comparator<CLASS_VALUE_TYPE>() {
|
||||
@Override
|
||||
public int compare(CLASS_VALUE_TYPE key, CLASS_VALUE_TYPE value) {
|
||||
return Integer.signum(indexOf(key) - indexOf(value));
|
||||
}
|
||||
|
||||
protected int indexOf(CLASS_VALUE_TYPE entry) {
|
||||
for(int i = 0,m=list.size();i<m;i++) {
|
||||
if(VALUE_EQUALS(list.get(i).ENTRY_VALUE(), OBJ_TO_VALUE(entry))) return i;
|
||||
}
|
||||
throw new IllegalArgumentException("MAP.values generator can order only sample values");
|
||||
}
|
||||
});
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
#if !VALUE_OBJECT
|
||||
@Override
|
||||
public VALUE_COLLECTION VALUE_GENERIC_TYPE create(VALUE_TYPE... elements) {
|
||||
Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
|
||||
int index = 0;
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
|
||||
result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.ENTRY_KEY(), elements[index++]);
|
||||
}
|
||||
return generator.create(result).values();
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public VALUE_COLLECTION VALUE_GENERIC_TYPE create(Object... elements) {
|
||||
Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
|
||||
int index = 0;
|
||||
for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
|
||||
result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), (CLASS_VALUE_TYPE)elements[index++]);
|
||||
}
|
||||
return generator.create(result).values();
|
||||
}
|
||||
}
|
||||
|
||||
public static KEY_VALUE_GENERIC_TYPE Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> entryObjectComparator(Comparator<CLASS_TYPE> keyComparator) {
|
||||
return new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
|
||||
@Override
|
||||
public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> a, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> b) {
|
||||
if(keyComparator == null) {
|
||||
return COMPAREABLE_TO_KEY(OBJ_TO_KEY(a.getKey()), OBJ_TO_KEY(b.getKey()));
|
||||
}
|
||||
return keyComparator.compare(OBJ_TO_KEY(a.getKey()), OBJ_TO_KEY(b.getKey()));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static KEY_VALUE_GENERIC_TYPE Comparator<Entry KEY_VALUE_GENERIC_TYPE> entryComparator(COMPARATOR KEY_GENERIC_TYPE keyComparator) {
|
||||
return new Comparator<Entry KEY_VALUE_GENERIC_TYPE>() {
|
||||
@Override
|
||||
public int compare(Entry KEY_VALUE_GENERIC_TYPE a, Entry KEY_VALUE_GENERIC_TYPE b) {
|
||||
if(keyComparator == null) {
|
||||
return COMPAREABLE_TO_KEY(a.ENTRY_KEY(), b.ENTRY_KEY());
|
||||
}
|
||||
return keyComparator.compare(a.ENTRY_KEY(), b.ENTRY_KEY());
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
+934
@@ -0,0 +1,934 @@
|
||||
package speiger.src.testers.PACKAGE.impl.maps;
|
||||
|
||||
#if TYPE_OBJECT || VALUE_OBJECT
|
||||
import java.util.Arrays;
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
import java.util.Comparator;
|
||||
#endif
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import org.junit.Assert;
|
||||
#endif
|
||||
import org.junit.Ignore;
|
||||
import org.junit.Test;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import com.google.common.collect.testing.AnEnum;
|
||||
#endif
|
||||
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.hash.HASH_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.hash.LINKED_HASH_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.customHash.CUSTOM_HASH_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.customHash.LINKED_CUSTOM_HASH_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.concurrent.CONCURRENT_HASH_MAP;
|
||||
#if TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
|
||||
#endif
|
||||
|
||||
import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
|
||||
import speiger.src.collections.PACKAGE.utils.STRATEGY;
|
||||
import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester;
|
||||
#if TYPE_OBJECT || VALUE_OBJECT
|
||||
import speiger.src.collections.objects.utils.StringSortTest;
|
||||
#endif
|
||||
|
||||
@Ignore
|
||||
@SuppressWarnings("javadoc")
|
||||
public class MAP_CONSTRUCTOR_TESTS
|
||||
{
|
||||
public static class HashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public HashMap() {
|
||||
setSimpleConstructor(MAP.builder()::map);
|
||||
setSizeConstructor(MAP.builder()::map);
|
||||
setPArrayConstructor(MAP.builder()::map);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(MAP.builder()::map);
|
||||
#endif
|
||||
setPMapConstructor(MAP.builder()::map);
|
||||
setMapConstructor(MAP.builder()::map);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongLoadFactorSize() {
|
||||
setSizeConstructor(T -> new HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 1 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public LinkedHashMap() {
|
||||
setSimpleConstructor(MAP.builder()::linkedMap);
|
||||
setSizeConstructor(MAP.builder()::linkedMap);
|
||||
setPArrayConstructor(MAP.builder()::linkedMap);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(MAP.builder()::linkedMap);
|
||||
#endif
|
||||
setPMapConstructor(MAP.builder()::linkedMap);
|
||||
setMapConstructor(MAP.builder()::linkedMap);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongLoadFactorSize() {
|
||||
setSizeConstructor(T -> new LINKED_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new LINKED_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 1 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
#if VALUE_OBJECT
|
||||
public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
|
||||
#else
|
||||
public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum>
|
||||
#endif
|
||||
{
|
||||
public EnumMap() {
|
||||
setSimpleConstructor(() -> new ENUM_MAP<>(AnEnum.class));
|
||||
setPArrayConstructor(ENUM_MAP::new);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(ENUM_MAP::new);
|
||||
#endif
|
||||
setPMapConstructor(ENUM_MAP::new);
|
||||
setMapConstructor(ENUM_MAP::new);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnumMapConstructor() {
|
||||
if(pMapConstructor == null) return;
|
||||
Assert.assertTrue(pMapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testObjectEnumMapConstructor() {
|
||||
if(pMapConstructor == null) return;
|
||||
Assert.assertTrue(mapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected AnEnum[] createKeyElements() {
|
||||
return AnEnum.values();
|
||||
}
|
||||
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOf(StringSortTest.NAMES, AnEnum.values().length);
|
||||
}
|
||||
#else
|
||||
@Override
|
||||
protected int getSize() {
|
||||
return AnEnum.values().length;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if VALUE_OBJECT
|
||||
public static class LinkedEnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
|
||||
#else
|
||||
public static class LinkedEnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum>
|
||||
#endif
|
||||
{
|
||||
public LinkedEnumMap() {
|
||||
setSimpleConstructor(() -> new LINKED_ENUM_MAP<>(AnEnum.class));
|
||||
setPArrayConstructor(LINKED_ENUM_MAP::new);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(LINKED_ENUM_MAP::new);
|
||||
#endif
|
||||
setPMapConstructor(LINKED_ENUM_MAP::new);
|
||||
setMapConstructor(LINKED_ENUM_MAP::new);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnumMapConstructor() {
|
||||
if(pMapConstructor == null) return;
|
||||
Assert.assertTrue(pMapConstructor.apply(new LINKED_ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
Assert.assertTrue(pMapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testObjectEnumMapConstructor() {
|
||||
if(mapConstructor == null) return;
|
||||
Assert.assertTrue(mapConstructor.apply(new LINKED_ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
Assert.assertTrue(mapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected AnEnum[] createKeyElements() {
|
||||
return AnEnum.values();
|
||||
}
|
||||
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOf(StringSortTest.NAMES, AnEnum.values().length);
|
||||
}
|
||||
#else
|
||||
@Override
|
||||
protected int getSize() {
|
||||
return AnEnum.values().length;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
public static class CustomHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public CustomHashMap() {
|
||||
setSimpleConstructor(() -> MAP.builder().customMap(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().customMap(K, V, HashStrategy.INSTANCE));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().customMap(K, V, HashStrategy.INSTANCE));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
|
||||
setMapConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongLoadFactorSize() {
|
||||
setSizeConstructor(T -> new CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F, HashStrategy.INSTANCE));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F, HashStrategy.INSTANCE));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 1 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedCustomHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public LinkedCustomHashMap() {
|
||||
setSimpleConstructor(() -> MAP.builder().customLinkedMap(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().customLinkedMap(K, V, HashStrategy.INSTANCE));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().customLinkedMap(K, V, HashStrategy.INSTANCE));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
|
||||
setMapConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongLoadFactorSize() {
|
||||
setSizeConstructor(T -> new LINKED_CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F, HashStrategy.INSTANCE));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new LINKED_CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F, HashStrategy.INSTANCE));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 1 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ImmutableHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ImmutableHashMap() {
|
||||
setPArrayConstructor(MAP.builder()::immutable);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(MAP.builder()::immutable);
|
||||
#endif
|
||||
setPMapConstructor(MAP.builder()::immutable);
|
||||
setMapConstructor(MAP.builder()::immutable);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ConcurrentHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ConcurrentHashMap() {
|
||||
setSimpleConstructor(CONCURRENT_HASH_MAP::new);
|
||||
setSizeConstructor(CONCURRENT_HASH_MAP::new);
|
||||
setPArrayConstructor(CONCURRENT_HASH_MAP::new);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(CONCURRENT_HASH_MAP::new);
|
||||
#endif
|
||||
setPMapConstructor(CONCURRENT_HASH_MAP::new);
|
||||
setMapConstructor(CONCURRENT_HASH_MAP::new);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongLoadFactorSize() {
|
||||
setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 1 LoadFactor should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWrongConcurrency() {
|
||||
setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 0 Concurrency should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
|
||||
setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, Integer.MAX_VALUE));
|
||||
try {
|
||||
testSizeConstructor_smallSize();
|
||||
fail("A Constructor using a 65536 or larger Concurrency should error");
|
||||
} catch(IllegalStateException e) {
|
||||
}
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ArrayMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ArrayMap() {
|
||||
setSimpleConstructor(MAP.builder()::arrayMap);
|
||||
setSizeConstructor(MAP.builder()::arrayMap);
|
||||
setPArrayConstructor(MAP.builder()::arrayMap);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(MAP.builder()::arrayMap);
|
||||
#endif
|
||||
setPMapConstructor(MAP.builder()::arrayMap);
|
||||
setMapConstructor(MAP.builder()::arrayMap);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public RBTreeMap() {
|
||||
setSimpleConstructor(MAP.builder()::rbTreeMap);
|
||||
setPArrayConstructor(RB_TREE_MAP::new);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(RB_TREE_MAP::new);
|
||||
#endif
|
||||
setPMapConstructor(RB_TREE_MAP::new);
|
||||
setMapConstructor(RB_TREE_MAP::new);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeMapComparator extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public RBTreeMapComparator() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPErbTreeMap(Comparator.naturalOrder()));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, Comparator.naturalOrder()));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, Comparator.naturalOrder()));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().rbTreeMap(T, Comparator.naturalOrder()));
|
||||
setMapConstructor(T -> MAP.builder().rbTreeMap(T, Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> MAP.builder().rbTreeMap(CLASS_TYPE::compare));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, CLASS_TYPE::compare));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, CLASS_TYPE::compare));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().rbTreeMap(T, CLASS_TYPE::compare));
|
||||
setMapConstructor(T -> MAP.builder().rbTreeMap(T, CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public AVLTreeMap() {
|
||||
setSimpleConstructor(MAP.builder()::avlTreeMap);
|
||||
setPArrayConstructor(AVL_TREE_MAP::new);
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor(AVL_TREE_MAP::new);
|
||||
#endif
|
||||
setPMapConstructor(AVL_TREE_MAP::new);
|
||||
setMapConstructor(AVL_TREE_MAP::new);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeMapComparator extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public AVLTreeMapComparator() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEavlTreeMap(Comparator.naturalOrder()));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, Comparator.naturalOrder()));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, Comparator.naturalOrder()));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().avlTreeMap(T, Comparator.naturalOrder()));
|
||||
setMapConstructor(T -> MAP.builder().avlTreeMap(T, Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> MAP.builder().avlTreeMap(CLASS_TYPE::compare));
|
||||
setPArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, CLASS_TYPE::compare));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, CLASS_TYPE::compare));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder().avlTreeMap(T, CLASS_TYPE::compare));
|
||||
setMapConstructor(T -> MAP.builder().avlTreeMap(T, CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
|
||||
static final HashStrategy INSTANCE = new HashStrategy();
|
||||
@Override
|
||||
public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
|
||||
@Override
|
||||
public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
|
||||
}
|
||||
|
||||
public static class HashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public HashMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().map());
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).map());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).map());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).map());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).map());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).map());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public LinkedHashMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().linkedMap());
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).linkedMap());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).linkedMap());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).linkedMap());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).linkedMap());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).linkedMap());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class CustomHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public CustomHashMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().customMap(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).customMap(HashStrategy.INSTANCE));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customMap(HashStrategy.INSTANCE));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customMap(HashStrategy.INSTANCE));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customMap(HashStrategy.INSTANCE));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customMap(HashStrategy.INSTANCE));
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class LinkedCustomHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public LinkedCustomHashMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().customLinkedMap(HashStrategy.INSTANCE));
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).customLinkedMap(HashStrategy.INSTANCE));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customLinkedMap(HashStrategy.INSTANCE));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customLinkedMap(HashStrategy.INSTANCE));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customLinkedMap(HashStrategy.INSTANCE));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customLinkedMap(HashStrategy.INSTANCE));
|
||||
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ImmutableHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ImmutableHashMapBuilder() {
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).immutable());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).immutable());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).immutable());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).immutable());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ConcurrentHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ConcurrentHashMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().concurrentMap());
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).concurrentMap());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).concurrentMap());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).concurrentMap());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).concurrentMap());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).concurrentMap());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class ArrayMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public ArrayMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().arrayMap());
|
||||
setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).arrayMap());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).arrayMap());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).arrayMap());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).arrayMap());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).arrayMap());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public RBTreeMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class RBTreeMapComparatorBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public RBTreeMapComparatorBuilder() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap(Comparator.naturalOrder()));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(Comparator.naturalOrder()));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(Comparator.naturalOrder()));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(Comparator.naturalOrder()));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap(CLASS_TYPE::compare));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(CLASS_TYPE::compare));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(CLASS_TYPE::compare));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(CLASS_TYPE::compare));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public AVLTreeMapBuilder() {
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap());
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap());
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap());
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap());
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class AVLTreeMapComparatorBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
|
||||
{
|
||||
public AVLTreeMapComparatorBuilder() {
|
||||
#if TYPE_OBJECT
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap(Comparator.naturalOrder()));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(Comparator.naturalOrder()));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(Comparator.naturalOrder()));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(Comparator.naturalOrder()));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(Comparator.naturalOrder()));
|
||||
#else
|
||||
setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap(CLASS_TYPE::compare));
|
||||
setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(CLASS_TYPE::compare));
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(CLASS_TYPE::compare));
|
||||
#endif
|
||||
setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(CLASS_TYPE::compare));
|
||||
setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(CLASS_TYPE::compare));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
protected String[] createKeyElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
@Override
|
||||
protected String[] createValueElements() {
|
||||
return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
private static MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE putAll(MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE cache, KEY_STRING_TYPE[] keys, VALUE_STRING_TYPE[] values) {
|
||||
if(keys.length != values.length) throw new IllegalStateException("Keys & Values lengths must match");
|
||||
for(int i = 0;i<keys.length;i++) {
|
||||
cache.put(keys[i], values[i]);
|
||||
}
|
||||
return cache;
|
||||
}
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
|
||||
private static MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE putAll(MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE cache, CLASS_STRING_TYPE[] keys, CLASS_STRING_VALUE_TYPE[] values) {
|
||||
if(keys.length != values.length) throw new IllegalStateException("Keys & Values lengths must match");
|
||||
for(int i = 0;i<keys.length;i++) {
|
||||
cache.put(keys[i], values[i]);
|
||||
}
|
||||
return cache;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
+200
@@ -0,0 +1,200 @@
|
||||
package speiger.src.testers.PACKAGE.impl.maps;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
import java.util.function.BiFunction;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
|
||||
import speiger.src.collections.objects.collections.ObjectIterable;
|
||||
#if TYPE_OBJECT || VALUE_OBJECT
|
||||
import speiger.src.collections.objects.utils.ObjectArrays;
|
||||
#endif
|
||||
import speiger.src.collections.objects.lists.ObjectList;
|
||||
import speiger.src.collections.objects.lists.ObjectArrayList;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
|
||||
import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
|
||||
import speiger.src.testers.objects.utils.ObjectSamples;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<E extends MAP KEY_VALUE_GENERIC_TYPE>
|
||||
{
|
||||
BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper;
|
||||
#if TYPE_BYTE
|
||||
KEY_TYPE[] keys = new KEY_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
|
||||
#else if TYPE_SHORT
|
||||
KEY_TYPE[] keys = new KEY_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
|
||||
#else if TYPE_CHAR
|
||||
KEY_TYPE[] keys = new KEY_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
|
||||
#else if TYPE_OBJECT
|
||||
KEY_TYPE[] keys;
|
||||
#else
|
||||
KEY_TYPE[] keys = new KEY_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
|
||||
#endif
|
||||
#if VALUE_BOOLEAN
|
||||
VALUE_TYPE[] values = new VALUE_TYPE[]{true, true, true, false, true, false, true, false, true};
|
||||
#else if VALUE_BYTE
|
||||
VALUE_TYPE[] values = new VALUE_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
|
||||
#else if VALUE_SHORT
|
||||
VALUE_TYPE[] values = new VALUE_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
|
||||
#else if VALUE_CHAR
|
||||
VALUE_TYPE[] values = new VALUE_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
|
||||
#else if VALUE_OBJECT
|
||||
VALUE_TYPE[] values;
|
||||
#else
|
||||
VALUE_TYPE[] values = new VALUE_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
|
||||
#endif
|
||||
|
||||
public SIMPLE_MAP_TEST_GENERATOR(BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper) {
|
||||
this.mapper = mapper;
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT || TYPE_CHAR
|
||||
public void setKeys(KEY_TYPE... keys) {
|
||||
this.keys = keys;
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_OBJECT || VALUE_CHAR
|
||||
public void setValues(VALUE_TYPE... values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
#endif
|
||||
public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
|
||||
return new ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE>(
|
||||
new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[0], values[0]),
|
||||
new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[1], values[1]),
|
||||
new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[2], values[2]),
|
||||
new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[3], values[3]),
|
||||
new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[4], values[4])
|
||||
);
|
||||
}
|
||||
|
||||
public E create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements) {
|
||||
#if TYPE_OBJECT
|
||||
KEY_TYPE[] keys = (T[])ObjectArrays.newArray(getSamples().e0().ENTRY_KEY().getClass(), elements.length);
|
||||
#else
|
||||
KEY_TYPE[] keys = NEW_KEY_ARRAY(elements.length);
|
||||
#endif
|
||||
#if VALUE_OBJECT
|
||||
VALUE_TYPE[] values = (V[])ObjectArrays.newArray(getSamples().e0().ENTRY_VALUE().getClass(), elements.length);
|
||||
#else
|
||||
VALUE_TYPE[] values = NEW_VALUE_ARRAY(elements.length);
|
||||
#endif
|
||||
for(int i = 0;i<elements.length;i++) {
|
||||
keys[i] = elements[i].ENTRY_KEY();
|
||||
values[i] = elements[i].ENTRY_VALUE();
|
||||
}
|
||||
return mapper.apply(keys, values);
|
||||
}
|
||||
|
||||
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public static class Maps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
public Maps(BiFunction<KEY_TYPE[], VALUE_TYPE[], MAP KEY_VALUE_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
public static class OrderedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<ORDERED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
public OrderedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], ORDERED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
public static class ConcurrentMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter;
|
||||
|
||||
public ConcurrentMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> mapper, Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter) {
|
||||
super(mapper);
|
||||
this.sorter = sorter;
|
||||
}
|
||||
|
||||
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
|
||||
ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> newList = new ObjectArrayList<>();
|
||||
for(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry : insertionOrder) {
|
||||
newList.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), entry.getValue()));
|
||||
}
|
||||
order(newList);
|
||||
insertionOrder.sort(new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
|
||||
@Override
|
||||
public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> key, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> value) {
|
||||
return Integer.signum(indexOf(OBJ_TO_KEY(key.getKey())) - indexOf(OBJ_TO_KEY(value.getKey())));
|
||||
}
|
||||
|
||||
protected int indexOf(KEY_TYPE key) {
|
||||
for(int i = 0,m=newList.size();i<m;i++) {
|
||||
if(KEY_EQUALS(newList.get(i).ENTRY_KEY(), key)) return i;
|
||||
}
|
||||
throw new IllegalArgumentException("MAP.entry sorter was corrupting data");
|
||||
}
|
||||
});
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
sorter.accept(insertionOrder);
|
||||
return insertionOrder;
|
||||
}
|
||||
}
|
||||
|
||||
public static class SortedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<SORTED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
public SortedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], SORTED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
|
||||
super(mapper);
|
||||
#if TYPE_CHAR
|
||||
setKeys(new KEY_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
|
||||
#endif
|
||||
#if VALUE_CHAR
|
||||
setValues(new VALUE_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
|
||||
#if TYPE_OBJECT
|
||||
insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator((Comparator<T>)Comparator.naturalOrder()));
|
||||
#else
|
||||
insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator(CLASS_TYPE::compare));
|
||||
#endif
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
|
||||
#if TYPE_OBJECT
|
||||
insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator((Comparator<T>)Comparator.naturalOrder()));
|
||||
#else
|
||||
insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator(CLASS_TYPE::compare));
|
||||
#endif
|
||||
return insertionOrder;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[5], values[5]); }
|
||||
@Override
|
||||
public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[6], values[6]); }
|
||||
@Override
|
||||
public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[7], values[7]); }
|
||||
@Override
|
||||
public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[8], values[8]); }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package speiger.src.testers.PACKAGE.impl.maps;
|
||||
|
||||
import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
|
||||
import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
|
||||
import speiger.src.collections.objects.collections.ObjectIterator;
|
||||
import speiger.src.collections.objects.sets.AbstractObjectSet;
|
||||
import speiger.src.collections.objects.sets.ObjectSet;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class SIMPLE_TEST_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
MAP KEY_VALUE_GENERIC_TYPE map;
|
||||
|
||||
public SIMPLE_TEST_MAP(KEY_TYPE[] keys, VALUE_TYPE[] values) {
|
||||
map = new ARRAY_MAPKV_BRACES(keys, values);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
|
||||
map.setDefaultReturnValue(v);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
|
||||
|
||||
@Override
|
||||
public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
|
||||
@Override
|
||||
public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
|
||||
#if VALUE_PRIMITIVES
|
||||
@Override
|
||||
public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
|
||||
@Override
|
||||
public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
|
||||
#endif
|
||||
@Override
|
||||
public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
|
||||
@Override
|
||||
public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
|
||||
#if !TYPE_OBJECT || !VALUE_OBJECT
|
||||
@Override
|
||||
public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
|
||||
#endif
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE remove(Object key) { return map.remove(key); }
|
||||
@Override
|
||||
public boolean remove(Object key, Object value) { return map.remove(key, value); }
|
||||
@Override
|
||||
public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
|
||||
#if TYPE_OBJECT && !VALUE_OBJECT
|
||||
@Override
|
||||
public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
|
||||
#endif
|
||||
@Override
|
||||
public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
|
||||
return new AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
|
||||
@Override
|
||||
public ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
|
||||
return new ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
|
||||
ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iter = map.ENTRY_SET().iterator();
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return iter.hasNext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
|
||||
MAP.Entry KEY_VALUE_GENERIC_TYPE entry = iter.next();
|
||||
return new ABSTRACT_MAP.BasicEntry KEY_VALUE_GENERIC_TYPE(entry.ENTRY_KEY(), entry.ENTRY_VALUE()) {
|
||||
@Override
|
||||
public VALUE_TYPE setValue(VALUE_TYPE value) {
|
||||
return entry.setValue(value);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
iter.remove();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return map.size();
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user