551 lines
22 KiB
Plaintext
551 lines
22 KiB
Plaintext
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());
|
|
}
|
|
};
|
|
}
|
|
}
|