Added Tests for Ordered Maps and more work on completing the

implementation

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");

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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(); }
 

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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(); }

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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(); }
 

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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(); }

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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(); }
 

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) {

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);

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(); }

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)) {

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)) {

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<CLASS_TYPE>
+public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, ORDERED_COLLECTION KEY_GENERIC_TYPE, SequencedSet<CLASS_TYPE>
 #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
 {
 	/**

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

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

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<Class<? extends AbstractTester>> 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;
 	}
 	

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())));
 	}

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())));

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<MAP.Entry KEY_VALUE_GENERIC_TYPE> 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();
+	}
+}

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());
 	}
 }

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() {

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);
 		}
 	}