Speiger/Primitive-Collections
0
0
Fork 1
Code Issues 1 Pull Requests Projects Releases 1 Wiki Activity

Small Fixes to doc and Useless Imports

Browse Source
This commit is contained in:
Speiger
2023-05-17 09:01:09 +02:00
parent 4dd3a4a6e8
commit ed9ce60af4
203 changed files with 51237 additions and 51213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/builder/resources/speiger/assets/testers/templates/impl/CollectionConstructorTests.template
+313 -313
View File
@@ -1,314 +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
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
}
src/builder/resources/speiger/assets/testers/templates/impl/SimpleQueueTestGenerator.template
+81 -81
View File
@@ -1,82 +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;
}
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;
}
}
src/builder/resources/speiger/assets/testers/templates/impl/SimpleTestGenerator.template
+220 -220
View File
@@ -1,221 +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
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
}
src/builder/resources/speiger/assets/testers/templates/impl/SortedSetSubsetTestSetGenerator.template
+173 -173
View File
@@ -1,173 +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);
}
}
}
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);
}
}
}
src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template
+550 -550
View File
File diff suppressed because it is too large Load Diff
src/builder/resources/speiger/assets/testers/templates/impl/maps/MapConstructorTests.template
+933 -933
View File
File diff suppressed because it is too large Load Diff
src/builder/resources/speiger/assets/testers/templates/impl/maps/SimpleMapTestGenerator.template
+200 -200
View File
@@ -1,200 +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]); }
}
}
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]); }
}
}
src/builder/resources/speiger/assets/testers/templates/impl/maps/TestMap.template
+91 -91
View File
@@ -1,92 +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();
}
};
}
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();
}
};
}
}