From 9f460912821c4bd5094eea6e593fb148891e6e16 Mon Sep 17 00:00:00 2001 From: Speiger Date: Tue, 12 May 2026 13:37:22 +0200 Subject: [PATCH] Added Tests for Ordered Maps and more work on completing the implementation --- .../src/builder/modules/MapModule.java | 1 + .../LinkedOpenCustomHashMap.template | 11 +- .../maps/impl/hash/LinkedOpenHashMap.template | 10 ++ .../immutable/ImmutableOpenHashMap.template | 10 ++ .../maps/impl/misc/ArrayMap.template | 8 ++ .../maps/impl/misc/LinkedEnumMap.template | 9 +- .../templates/sets/AbstractSet.template | 12 +- .../templates/sets/ArraySet.template | 19 +++ .../sets/ImmutableOpenHashSet.template | 4 + .../sets/LinkedOpenCustomHashSet.template | 40 ++++++ .../templates/sets/LinkedOpenHashSet.template | 40 ++++++ .../templates/sets/OrderedSet.template | 5 +- .../collections/templates/utils/Sets.template | 10 +- .../templates/utils/maps/Maps.template | 6 +- .../maps/OrderedMapTestSuiteBuilder.template | 2 + .../tests/maps/MapContainsTester.template | 2 + .../tests/maps/MapRemoveEntryTester.template | 2 + .../tests/maps/OrderedMapPutTester.template | 122 ++++++++++++++++++ .../iterators/QueueFindFirstTester.template | 11 +- .../iterators/QueueReduceTester.template | 8 +- .../base/BaseInt2IntNavigableMapTest.java | 21 +-- 21 files changed, 326 insertions(+), 27 deletions(-) create mode 100644 src/builder/resources/speiger/assets/testers/templates/tests/maps/OrderedMapPutTester.template diff --git a/src/builder/java/speiger/src/builder/modules/MapModule.java b/src/builder/java/speiger/src/builder/modules/MapModule.java index 41dba85..87ce295 100644 --- a/src/builder/java/speiger/src/builder/modules/MapModule.java +++ b/src/builder/java/speiger/src/builder/modules/MapModule.java @@ -198,6 +198,7 @@ public class MapModule extends BaseModule addBiRequirement("SortedMapNavigationTester"); addBiRequirement("OrderedMapNavigationTester"); addBiRequirement("OrderedMapMoveTester"); + addBiRequirement("OrderedMapPutTester"); addBiRequirement("MapConstructorTester"); addRemapper("TestMapGenerator", "Test%sMapGenerator"); diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template index b921b89..54fdcca 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template @@ -713,6 +713,10 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } private class MapEntrySet extends AbstractObjectSet implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE { + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -1004,10 +1008,13 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); } - + + @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } - @Override public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template index 9c27197..8cec210 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template @@ -717,6 +717,10 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } private class MapEntrySet extends AbstractObjectSet implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE { + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -1003,6 +1007,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G #endif @Override public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); } + + @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template index 7269b24..c9936fe 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template @@ -637,6 +637,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } private class MapEntrySet extends AbstractObjectSet implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE { + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -894,6 +898,12 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ throw new UnsupportedOperationException(); } + @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template index 9097ac9..b69a432 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template @@ -868,6 +868,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } private class MapEntrySet extends AbstractObjectSet implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE { + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -1126,6 +1130,10 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN @Override public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template index 35a913a..0429062 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template @@ -473,6 +473,10 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } private class MapEntrySet extends AbstractObjectSet implements ORDERED_MAP.FastOrderedSet KEY_VALUE_GENERIC_TYPE { + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -637,7 +641,10 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA public boolean add(T o) { throw new UnsupportedOperationException(); } - + @Override + public void addFirst(T o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(T o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(T o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template index 468c4b8..c9b2b15 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template @@ -73,7 +73,17 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return set.iterator(); } - + + @Override + public void addFirst(KEY_TYPE o) { + set.addLast(o); + } + + @Override + public void addLast(KEY_TYPE o) { + set.addFirst(o); + } + @Override #if !TYPE_OBJECT public boolean remove(KEY_TYPE o) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template b/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template index eacee22..74558f6 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template @@ -153,6 +153,25 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im } #endif + @Override + public void addFirst(KEY_TYPE o) { + int index = findIndex(o); + if(index == -1) { + if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2); + System.arraycopy(data, 0, data, 1, size++); + data[0] = o; + } + } + + @Override + public void addLast(KEY_TYPE o) { + int index = findIndex(o); + if(index == -1) { + if(data.length == size) data = Arrays.copyOf(data, size == 0 ? 2 : size * 2); + data[size++] = o; + } + } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { int index = findIndex(o); diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template index d2fcd4e..ba70686 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template @@ -264,6 +264,10 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI @Override public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) { throw new UnsupportedOperationException(); } @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template index b9950b0..de92850 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template @@ -241,6 +241,46 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY } #endif + @Override + public void addFirst(KEY_TYPE o) { + if(strategy.equals(o, EMPTY_KEY_VALUE)) { + if(containsNull) return; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(strategy.hashCode(o)) & mask; + while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) { + if(strategy.equals(keys[pos], o)) return; + pos = ++pos & mask; + } + keys[pos] = o; + onNodeAdded(pos); + moveToFirstIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + } + + @Override + public void addLast(KEY_TYPE o) { + if(strategy.equals(o, EMPTY_KEY_VALUE)) { + if(containsNull) return; + containsNull = true; + onNodeAdded(nullIndex); + } + else { + int pos = HashUtil.mix(strategy.hashCode(o)) & mask; + while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) { + if(strategy.equals(keys[pos], o)) return; + pos = ++pos & mask; + } + keys[pos] = o; + onNodeAdded(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { if(strategy.equals(o, EMPTY_KEY_VALUE)) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template index 8247c8d..81f4244 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template @@ -212,6 +212,46 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE } #endif + @Override + public void addFirst(KEY_TYPE o) { + if(KEY_EQUALS_NULL(o)) { + if(containsNull) return; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask; + while(KEY_EQUALS_NOT_NULL(keys[pos])) { + if(KEY_EQUALS(keys[pos], o)) return; + pos = ++pos & mask; + } + keys[pos] = o; + onNodeAdded(pos); + moveToFirstIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + } + + @Override + public void addLast(KEY_TYPE o) { + if(KEY_EQUALS_NULL(o)) { + if(containsNull) return; + containsNull = true; + onNodeAdded(nullIndex); + } + else { + int pos = HashUtil.mix(KEY_TO_HASH(o)) & mask; + while(KEY_EQUALS_NOT_NULL(keys[pos])) { + if(KEY_EQUALS(keys[pos], o)) return; + pos = ++pos & mask; + } + keys[pos] = o; + onNodeAdded(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + } + @Override public boolean addAndMoveToFirst(KEY_TYPE o) { if(KEY_EQUALS_NULL(o)) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template index 7a31a48..ce1791c 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template @@ -5,6 +5,7 @@ import java.util.SequencedSet; #endif import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION; #if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; @@ -23,9 +24,9 @@ import speiger.src.collections.PACKAGE.utils.SETS; * @Type(T) */ #if JAVA_VERSION>=21 -public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SequencedSet +public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE, SequencedSet #else -public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE +public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE #endif { /** diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template b/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template index 78b0e8f..dc28f72 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template @@ -360,6 +360,10 @@ public class SETS s = c; } + @Override + public void addFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); } @Override @@ -650,7 +654,11 @@ public class SETS super(c, mutex); s = c; } - + + @Override + public void addFirst(KEY_TYPE o) { synchronized(mutex) { s.addFirst(o); } } + @Override + public void addLast(KEY_TYPE o) { synchronized(mutex) { s.addLast(o); } } @Override public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } } @Override diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template b/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template index 6bf3db4..7318693 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template @@ -754,7 +754,11 @@ public class MAPS super(c); set = c; } - + + @Override + public void addFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } + @Override + public void addLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override public boolean addAndMoveToFirst(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override diff --git a/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template b/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template index 5568ad5..03cc30b 100644 --- a/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template +++ b/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template @@ -20,6 +20,7 @@ import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR; import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS; import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester; import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester; +import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester; #if !TYPE_OBJECT import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder; import speiger.src.testers.objects.generators.TestObjectSetGenerator; @@ -41,6 +42,7 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU List> testers = super.getTesters(); testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class); testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class); + testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester.class); return testers; } diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapContainsTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapContainsTester.template index f6ccbb3..1a0ff8b 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapContainsTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapContainsTester.template @@ -27,6 +27,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY #ignore @CollectionSize.Require(absent = ZERO) + @SuppressWarnings("unlikely-arg-type") #endignore public void testContainsObject_yes() { assertTrue("contains(present) should return true", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e0()))); @@ -36,6 +37,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester KEY_VALUE_GENERIC_TY assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(e3())); } + @SuppressWarnings("unlikely-arg-type") public void testContainsObject_no() { assertFalse("contains(notPresent) should return false", getMap().ENTRY_SET().contains(new AbstractMap.SimpleEntry<>(e3()))); } diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapRemoveEntryTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapRemoveEntryTester.template index 80c5161..f08fe85 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapRemoveEntryTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/maps/MapRemoveEntryTester.template @@ -136,6 +136,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC #ignore @CollectionSize.Require(ONE) @MapFeature.Require(SUPPORTS_REMOVE) + @SuppressWarnings("unlikely-arg-type") #endignore public void testRemove_supportedObjectEntryPresent() { assertTrue(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e0()))); @@ -154,6 +155,7 @@ public class FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester KEY_VALUE_GENERIC #ignore @CollectionSize.Require(ONE) @MapFeature.Require(SUPPORTS_REMOVE) + @SuppressWarnings("unlikely-arg-type") #endignore public void testRemove_supportedObjectEntryMissing() { assertFalse(getMap().ENTRY_SET().remove(new AbstractMap.SimpleEntry<>(e3()))); diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/maps/OrderedMapPutTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/maps/OrderedMapPutTester.template new file mode 100644 index 0000000..4aa0596 --- /dev/null +++ b/src/builder/resources/speiger/assets/testers/templates/tests/maps/OrderedMapPutTester.template @@ -0,0 +1,122 @@ +package speiger.src.testers.PACKAGE.tests.maps; + +#ignore +import static com.google.common.collect.testing.features.CollectionSize.ZERO; +import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT; +import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_REMOVE; +import static org.junit.Assert.assertNotEquals; +#endignore + +import com.google.common.collect.testing.features.CollectionSize; +import com.google.common.collect.testing.features.MapFeature; + +import speiger.src.collections.PACKAGE.maps.interfaces.MAP; +import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP; +import speiger.src.collections.objects.lists.ObjectList; +import speiger.src.testers.PACKAGE.tests.base.maps.ABSTRACT_MAP_TESTER; +import speiger.src.testers.objects.utils.ObjectHelpers; + +@SuppressWarnings("javadoc") +public class FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapPutTester KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP_TESTER KEY_VALUE_GENERIC_TYPE +{ + private ORDERED_MAP KEY_VALUE_GENERIC_TYPE orderedMap; + private ObjectList values; + private KEY_TYPE a; + private VALUE_TYPE aValue; + private VALUE_TYPE cValue; + + @Override + public void setUp() throws Exception { + super.setUp(); + orderedMap = (ORDERED_MAP KEY_VALUE_GENERIC_TYPE)getMap(); + values = ObjectHelpers.copyToList(getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements())); + if (values.size() >= 1) { + a = values.get(0).ENTRY_KEY(); + aValue = values.get(0).ENTRY_VALUE(); + if (values.size() >= 3) { + cValue = values.get(2).ENTRY_VALUE(); + } + } + } + +#ignore + @MapFeature.Require(SUPPORTS_PUT) + @CollectionSize.Require(absent = ZERO) +#endignore + public void testPutFirst() { + assertEquals(aValue, orderedMap.putFirst(a, cValue)); + assertNotEquals(cValue, orderedMap.FIRST_ENTRY_VALUE()); + assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putFirst(k4(), v4())); + assertNotEquals(v4(), orderedMap.FIRST_ENTRY_VALUE()); + assertEquals(e4(), orderedMap.firstEntry()); + } + + +#ignore + @MapFeature.Require(SUPPORTS_PUT) + @CollectionSize.Require(absent = ZERO) +#endignore + public void testPutLast() { + assertEquals(aValue, orderedMap.putLast(a, cValue)); + assertNotEquals(cValue, orderedMap.LAST_ENTRY_VALUE()); + assertEquals(orderedMap.getDefaultReturnValue(), orderedMap.putLast(k4(), v4())); + assertNotEquals(v4(), orderedMap.LAST_ENTRY_VALUE()); + assertEquals(e4(), orderedMap.lastEntry()); + } + +#ignore + @MapFeature.Require(SUPPORTS_REMOVE) + @CollectionSize.Require(CollectionSize.ONE) +#endignore + public void testPollFirst() { + assertFalse(orderedMap.isEmpty()); + assertEquals(e0(), orderedMap.pollFirstEntry()); + assertTrue(orderedMap.isEmpty()); + } + +#ignore + @MapFeature.Require(SUPPORTS_REMOVE) + @CollectionSize.Require(CollectionSize.ONE) +#endignore + public void testPollLast() { + assertFalse(orderedMap.isEmpty()); + assertEquals(e0(), orderedMap.pollLastEntry()); + assertTrue(orderedMap.isEmpty()); + } + +#ignore + @MapFeature.Require(absent = SUPPORTS_PUT) +#endignore + public void testUnsupportedPutFirst() { + try { orderedMap.putFirst(a, aValue); } + catch (UnsupportedOperationException tolerated) {} + expectUnchanged(); + } + +#ignore + @MapFeature.Require(absent = SUPPORTS_PUT) +#endignore + public void testUnsupportedPutLast() { + try { orderedMap.putLast(a, aValue); } + catch (UnsupportedOperationException tolerated) {} + expectUnchanged(); + } + +#ignore + @MapFeature.Require(absent = SUPPORTS_REMOVE) +#endignore + public void testUnsupportedPollFirst() { + try { orderedMap.pollFirstEntry(); } + catch (UnsupportedOperationException tolerated) {} + expectUnchanged(); + } + +#ignore + @MapFeature.Require(absent = SUPPORTS_REMOVE) +#endignore + public void testUnsupportedPollLast() { + try { orderedMap.pollFirstEntry(); } + catch (UnsupportedOperationException tolerated) {} + expectUnchanged(); + } +} \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueFindFirstTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueFindFirstTester.template index aa90be0..a109ac9 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueFindFirstTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueFindFirstTester.template @@ -2,6 +2,11 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators; #if TYPE_OBJECT import java.util.Objects; +#endif +#if JDK_TYPE +import java.util.OPTIONAL; +#else +import speiger.src.collections.PACKAGE.functions.OPTIONAL; #endif import org.junit.Ignore; @@ -27,17 +32,17 @@ public class FILE_KEY_TYPEQueueFindFirstTester KEY_GENERIC_TYPE extends ABSTRACT @CollectionSize.Require(absent = CollectionSize.ZERO) #endignore public void testQueueFindFirst_FindFirstElements() { - assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0()))); + assertEquals("First Element should be found", e0(), queue.findFirst(T -> KEY_EQUALS(T, e0())).SUPPLY_GET()); } public void testQueueFindFirst_FindNothing() { - assertEquals("No element should be found", EMPTY_KEY_VALUE, queue.findFirst(T -> KEY_EQUALS(T, e4()))); + assertEquals("No element should be found", OPTIONAL.empty(), queue.findFirst(T -> KEY_EQUALS(T, e4()))); } #ignore @CollectionSize.Require(CollectionSize.SEVERAL) #endignore public void testQueueFindFirst_FindLastElement() { - assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2()))); + assertEquals("Last Element should be found", e2(), queue.findFirst(T -> KEY_EQUALS(T, e2())).SUPPLY_GET()); } } diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueReduceTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueReduceTester.template index 5cc29b6..c4517fa 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueReduceTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/queue/iterators/QueueReduceTester.template @@ -3,10 +3,16 @@ package speiger.src.testers.PACKAGE.tests.queue.iterators; #if TYPE_OBJECT import java.util.Objects; +#endif +#if JDK_TYPE +import java.util.OPTIONAL; +#else +import speiger.src.collections.PACKAGE.functions.OPTIONAL; #endif import org.junit.Ignore; import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_QUEUE_TESTER; +import com.google.common.collect.testing.features.CollectionSize; @Ignore @SuppressWarnings("javadoc") @@ -29,7 +35,7 @@ public class FILE_KEY_TYPEQueueReduceTester KEY_GENERIC_TYPE extends ABSTRACT_QU } public void testQueueReduce() { - assertEquals("The sum of the queue should match", getSum(), queue.reduce(this::sum)); + assertEquals("The sum of the queue should match", size == CollectionSize.ZERO ? OPTIONAL.empty() : OPTIONAL.GET_OPTIONAL(getSum()), queue.reduce(this::sum)); } public void testQueueExtraReduce() { diff --git a/src/test/java/speiger/src/collections/ints/base/BaseInt2IntNavigableMapTest.java b/src/test/java/speiger/src/collections/ints/base/BaseInt2IntNavigableMapTest.java index 1772330..d8973a3 100644 --- a/src/test/java/speiger/src/collections/ints/base/BaseInt2IntNavigableMapTest.java +++ b/src/test/java/speiger/src/collections/ints/base/BaseInt2IntNavigableMapTest.java @@ -9,8 +9,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2IntNavigableMap; import speiger.src.collections.tests.NavigableSetTest; @SuppressWarnings("javadoc") -public abstract class BaseInt2IntNavigableMapTest extends BaseInt2IntSortedMapTest -{ +public abstract class BaseInt2IntNavigableMapTest extends BaseInt2IntSortedMapTest { @Override public abstract Int2IntNavigableMap createMap(int[] keys, int[] values); @Override @@ -29,30 +28,22 @@ public abstract class BaseInt2IntNavigableMapTest extends BaseInt2IntSortedMapTe @Test public void lowerTest() { - if(getValidNavigableMapTests().contains(NavigableSetTest.LOWER)) { - Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).lowerKey(50) < 50); - } + if(getValidNavigableMapTests().contains(NavigableSetTest.LOWER)) { Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).lowerKey(50) < 50); } } @Test public void higherTest() { - if(getValidNavigableMapTests().contains(NavigableSetTest.HIGHER)) { - Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).higherKey(50) > 50); - } + if(getValidNavigableMapTests().contains(NavigableSetTest.HIGHER)) { Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).higherKey(50) > 50); } } @Test public void ceilTest() { - if(getValidNavigableMapTests().contains(NavigableSetTest.CEILING)) { - Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).ceilingKey(50) >= 50); - } + if(getValidNavigableMapTests().contains(NavigableSetTest.CEILING)) { Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).ceilingKey(50) >= 50); } } @Test public void floorTest() { - if(getValidNavigableMapTests().contains(NavigableSetTest.FLOOR)) { - Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).floorKey(50) <= 50); - } + if(getValidNavigableMapTests().contains(NavigableSetTest.FLOOR)) { Assert.assertTrue(createMap(TEST_ARRAY, TEST_ARRAY).floorKey(50) <= 50); } } @Test @@ -75,7 +66,7 @@ public abstract class BaseInt2IntNavigableMapTest extends BaseInt2IntSortedMapTe Assert.assertTrue(subSet.lowerKey(50) < 50); Assert.assertTrue(subSet.higherKey(50) > 50); Assert.assertTrue(subSet.ceilingKey(50) >= 50); - Assert.assertTrue(subSet.floorKey(50) <= 50); + Assert.assertTrue(subSet.floorKey(50) <= 50); } }