Refactor of the Project on Github.

-Added: Better System to decide what code should be generated.
-Added: Unit Tests are now included in the main branch.
-Added: Automatic System to test the main branch and ensure that tests work.
-Added: Pull Requests now run tests too.

.github/workflows/build_action.yml

@@ -0,0 +1,34 @@
+name: Latest Build
+
+on:
+   push:
+      branches: [ master ]
+   pull_request:
+      branches: [ master ]
+
+jobs:
+   build:
+      strategy:
+         fail-fast: false
+         matrix:
+            jdk: [8, 11, 14, 16, 17]
+
+      runs-on: ubuntu-latest
+      steps:
+         - uses: actions/checkout@v2
+         
+         - name: Set up JDK ${{ matrix.jdk }}
+           uses: actions/setup-java@v3
+           with:
+               java-version: ${{ matrix.jdk }}
+               distribution: temurin
+               cache: gradle
+
+         - name: Validate Gradle wrapper
+           uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+
+         - name: Make gradlew executable
+           run: chmod +x ./gradlew
+
+         - name: Build with Gradle
+           run: ./gradlew build

.github/workflows/build_tests_action.yml

@@ -0,0 +1,84 @@
+name: Unit Tests
+
+on:
+   push:
+      branches: [ master ]
+      
+jobs:
+   build:
+      name: Unit Tests
+      runs-on: ubuntu-latest
+      steps:
+      -  uses: actions/checkout@v2
+         with:
+            fetch-depth: 0
+            
+      -  name: Set up JDK 11
+         uses: actions/setup-java@v3
+         with:
+            distribution: temurin
+            java-version: 11
+            cache: gradle
+            
+      -  name: Make gradlew executable
+         run: chmod +x ./gradlew
+      -  name: Build and Test
+         env:
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+         run: ./gradlew generateTestSource test jacocoTestReport --info -Dfull_test_suite=true
+         
+      -  name: Publish Test Result
+         uses: EnricoMi/publish-unit-test-result-action@v1
+         id: test-results
+         if: always()
+         with:
+            files: build/test-results/**/*.xml
+            fail_on: nothing
+            ignore_runs: true
+            json_thousands_separator: .
+            time_unit: milliseconds
+            
+      -  name: Create Badge Color
+         shell: bash
+         run: |
+            case ${{ fromJSON( steps.test-results.outputs.json ).conclusion }} in
+              success)
+                echo "BADGE_COLOR=31c653" >> $GITHUB_ENV
+                ;;
+              failure)
+                echo "BADGE_COLOR=800000" >> $GITHUB_ENV
+                ;;
+              neutral)
+                echo "BADGE_COLOR=696969" >> $GITHUB_ENV
+                ;;
+            esac
+
+      -  name: Create Test Badge
+         uses: emibcn/badge-action@v1.2.4
+         with:
+            label: Tests
+            status: '${{ fromJSON( steps.test-results.outputs.json ).conclusion }}, Passed: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_succ }}, Skipped: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_skip }}, Failed: ${{ fromJSON( steps.test-results.outputs.json ).formatted.stats.tests_fail }}'
+            color: ${{ env.BADGE_COLOR }}
+            path: tests.svg
+
+      -  name: Create Coverage Badge
+         id: jacoco
+         uses: cicirello/jacoco-badge-generator@v2
+         with:
+            jacoco-csv-file: build/reports/jacoco/test/jacocoTestReport.csv
+            badges-directory: null
+            intervals: 95 80 70 60 50 0
+      
+      -  name: Upload Test Badge
+         uses: exuanbo/actions-deploy-gist@v1
+         with:
+            token: ${{ secrets.GIST_TOKEN }}
+            gist_id: 280257cd19cbe1dda3789bebd4ff65cf
+            file_path: tests.svg
+            
+      -  name: Upload Coverage Badge
+         uses: exuanbo/actions-deploy-gist@v1
+         with:
+            token: ${{ secrets.GIST_TOKEN }}
+            gist_id: 280257cd19cbe1dda3789bebd4ff65cf
+            file_path: jacoco.svg

.github/workflows/build_validator.yml

@@ -1,36 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
-
-name: Latest Build
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        jdk: [8, 11, 14, 16, 17]
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK ${{ matrix.jdk }}
-      uses: actions/setup-java@v1
-      with:
-        java-version: ${{ matrix.jdk }}
-    - name: Validate Gradle wrapper
-      uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
-    - name: Make gradlew executable
-      run: chmod +x ./gradlew
-    - name: Build with Gradle
-      run: ./gradlew build

.github/workflows/pull_build_tests_action.yml

@@ -0,0 +1,39 @@
+name: Unit Tests
+
+on:
+   pull_request:
+      branches: [ master ]
+
+jobs:
+   build:
+      name: Unit Tests
+      runs-on: ubuntu-latest
+      steps:
+      -  uses: actions/checkout@v2
+         with:
+            fetch-depth: 0
+            
+      -  name: Set up JDK 11
+         uses: actions/setup-java@v3
+         with:
+            distribution: temurin
+            java-version: 11
+            cache: gradle
+            
+      -  name: Make gradlew executable
+         run: chmod +x ./gradlew
+      -  name: Build and Test
+         env:
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+         run: ./gradlew generateTestSource test jacocoTestReport --info -Dfull_test_suite=true
+         
+      -  name: Publish Test Result
+         uses: EnricoMi/publish-unit-test-result-action@v1
+         id: test-results
+         if: always()
+         with:
+            files: build/test-results/**/*.xml
+            fail_on: nothing
+            ignore_runs: true
+            json_thousands_separator: .
+            time_unit: milliseconds

.gitignore

@@ -30,5 +30,19 @@ gradle-app.setting
 /src/main/java/speiger/src/collections/doubles/*
 /src/main/java/speiger/src/collections/objects/*
 
+#Generated Tests
+/src/test/java/speiger/src/testers/booleans/*
+/src/test/java/speiger/src/testers/bytes/*
+/src/test/java/speiger/src/testers/shorts/*
+/src/test/java/speiger/src/testers/chars/*
+/src/test/java/speiger/src/testers/ints/*
+/src/test/java/speiger/src/testers/longs/*
+/src/test/java/speiger/src/testers/floats/*
+/src/test/java/speiger/src/testers/doubles/*
+/src/test/java/speiger/src/testers/objects/*
+/src/test/java/speiger/src/tests/*
+
 #Cache result
 /src/builder/resources/speiger/assets/collections/cache.bin
+/src/builder/resources/speiger/assets/testers/cache.bin
+/src/builder/resources/speiger/assets/tests/cache.bin

build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java-library'
+    id "jacoco"
 }
 
 tasks.withType(JavaCompile) {
@@ -62,7 +63,7 @@ task generateGithubSource(type: JavaExec) {
 	description = 'Builds the sourcecode for Github Actions'
  	classpath = sourceSets.builder.runtimeClasspath
  	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
- 	args = ['false', 'true']
+ 	args = ['silent']
 }
 
 task forceGenerateSource(type: JavaExec) {
@@ -70,7 +71,15 @@ task forceGenerateSource(type: JavaExec) {
 	description = 'Builds the sourcecode forceful'
  	classpath = sourceSets.builder.runtimeClasspath
  	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
- 	args = ['true']
+ 	args = ['force']
+}
+
+task generateTestSource(type: JavaExec) {
+	group = 'internal'
+	description = 'Builds the sourcecode for the Tests'
+ 	classpath = sourceSets.builder.runtimeClasspath
+ 	main = 'speiger.src.builder.PrimitiveCollectionsBuilder'
+ 	args = ['tests']
 }
 
 task javadocJar(type: Jar) {
@@ -94,8 +103,152 @@ artifacts {
     archives srcJar
 }
 
+task testBooleans(type: Test) {
+	group 'tests'
+	description 'Tests all Boolean Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.booleans.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+}
+
+task testBytes(type: Test) {
+	group 'tests'
+	description 'Tests all Byte Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.bytes.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testShorts(type: Test) {
+	group 'tests'
+	description 'Tests all Short Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.shorts.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testChars(type: Test) {
+	group 'tests'
+	description 'Tests all Character Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.chars.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testInts(type: Test) {
+	group 'tests'
+	description 'Tests all Int Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.ints.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testLongs(type: Test) {
+	group 'tests'
+	description 'Tests all Long Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.longs.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testFloats(type: Test) {
+	group 'tests'
+	description 'Tests all Float Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.floats.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testDoubles(type: Test) {
+	group 'tests'
+	description 'Tests all Double Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.doubles.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+task testObjects(type: Test) {
+	group 'tests'
+	description 'Tests all Object Collections'
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		includeTestsMatching "speiger.src.tests.objects.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+	maxParallelForks = 2
+}
+
+if(System.getProperty("full_test_suite", "false").toBoolean()) {
+	test.dependsOn testBooleans
+	test.dependsOn testBytes
+	test.dependsOn testShorts
+	test.dependsOn testChars
+	test.dependsOn testInts
+	test.dependsOn testLongs
+	test.dependsOn testFloats
+	test.dependsOn testDoubles
+	test.dependsOn testObjects
+}
+
 test {
-    useJUnit()
+	filter {
+		excludeTestsMatching "speiger.src.testers.**.*"
+		excludeTestsMatching "speiger.src.tests.**.*"
+		excludeTestsMatching "tests.**.*"
+	}
+	useJUnit()
+	ignoreFailures = true
+	maxHeapSize = "1024m"
+}
+
+jacocoTestReport {
+    executionData fileTree(project.buildDir.absolutePath).include("jacoco/*.exec")
+    reports {
+        xml.enabled true
+        html.enabled = true
+        csv.enabled true
+    }
 }
 
 publishing {

src/builder/java/speiger/src/builder/ClassType.java

@@ -3,15 +3,15 @@ package speiger.src.builder;
 @SuppressWarnings("javadoc")
 public enum ClassType
 {
-	BOOLEAN("boolean", "Boolean", "Boolean", "booleans", "BOOLEAN", "false"),
-	BYTE("byte", "Byte", "Byte", "bytes", "BYTE", "(byte)0"),
-	SHORT("short", "Short", "Short", "shorts", "SHORT", "(short)0"),
-	CHAR("char", "Character", "Char", "chars", "CHAR", "(char)0"),
-	INT("int", "Integer", "Int", "ints", "INT", "0"),
-	LONG("long", "Long", "Long", "longs", "LONG", "0L"),
-	FLOAT("float", "Float", "Float", "floats", "FLOAT", "0F"),
-	DOUBLE("double", "Double", "Double", "doubles", "DOUBLE", "0D"),
-	OBJECT("T", "T", "Object", "objects", "OBJECT", "null");
+	BOOLEAN("boolean", "Boolean", "Boolean", "booleans", "BOOLEAN", "false", "false"),
+	BYTE("byte", "Byte", "Byte", "bytes", "BYTE", "(byte)0", "(byte)-1"),
+	SHORT("short", "Short", "Short", "shorts", "SHORT", "(short)0", "(short)-1"),
+	CHAR("char", "Character", "Char", "chars", "CHAR", "(char)0", "(char)-1"),
+	INT("int", "Integer", "Int", "ints", "INT", "0", "-1"),
+	LONG("long", "Long", "Long", "longs", "LONG", "0L", "-1L"),
+	FLOAT("float", "Float", "Float", "floats", "FLOAT", "0F", "-1F"),
+	DOUBLE("double", "Double", "Double", "doubles", "DOUBLE", "0D", "-1D"),
+	OBJECT("T", "T", "Object", "objects", "OBJECT", "null", "null");
 	
 	String keyType;
 	String classType;
@@ -19,8 +19,9 @@ public enum ClassType
 	String pathType;
 	String capType;
 	String emptyValue;
+	String invalidValue;
 	
-	private ClassType(String keyType, String classType, String fileType, String pathType, String capType, String emptyValue)
+	private ClassType(String keyType, String classType, String fileType, String pathType, String capType, String emptyValue, String invalidValue)
 	{
 		this.keyType = keyType;
 		this.classType = classType;
@@ -28,6 +29,7 @@ public enum ClassType
 		this.pathType = pathType;
 		this.capType = capType;
 		this.emptyValue = emptyValue;
+		this.invalidValue = invalidValue;
 	}
 	
 	public String getKeyType()
@@ -90,6 +92,11 @@ public enum ClassType
 		return emptyValue;
 	}
 	
+	public String getInvalidValue()
+	{
+		return invalidValue;
+	}
+	
 	public boolean isObject()
 	{
 		return this == OBJECT;

src/builder/java/speiger/src/builder/GlobalVariables.java

@@ -35,21 +35,43 @@ public class GlobalVariables
 		addSimpleMapper("CLASS_TYPE", type.getClassType());
 		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
 		addSimpleMapper("KEY_TYPE", type.getKeyType());
+		addSimpleMapper("KEY_OBJECT_TYPE", type.isObject() ? "Object" : type.getKeyType());
+		addSimpleMapper("KEY_STRING_TYPE", type.isObject() ? "String" : type.getKeyType());
 		addSimpleMapper("KEY_SPECIAL_TYPE", type.isObject() ? "E" : type.getKeyType());
+		addSimpleMapper("CLASS_OBJECT_TYPE", type.getClassType());
+		addSimpleMapper("CLASS_OBJECT_VALUE_TYPE", valueType.getClassValueType());
+		addSimpleMapper("CLASS_STRING_TYPE", type.isObject() ? "String" : type.getClassType());
+		addSimpleMapper("CLASS_STRING_VALUE_TYPE", valueType.isObject() ? "String" : valueType.getClassValueType());
 		addSimpleMapper("VALUE_TYPE", valueType.getValueType());
+		addSimpleMapper("VALUE_OBJECT_TYPE", valueType.isObject() ? "Object" : valueType.getValueType());
+		addSimpleMapper("VALUE_STRING_TYPE", valueType.isObject() ? "String" : valueType.getValueType());
 		addSimpleMapper("VALUE_SPECIAL_TYPE", valueType.isObject() ? "E" : valueType.getKeyType());
+		addSimpleMapper("KEY_JAVA_TYPE", type.getCustomJDKType().getKeyType());
+		addSimpleMapper("VALUE_JAVA_TYPE", type.getCustomJDKType().getKeyType());
 		
 		addSimpleMapper("EMPTY_KEY_VALUE", type.getEmptyValue());
 		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
 		
+		addSimpleMapper("INVALID_KEY_VALUE", type.getInvalidValue());
+		addSimpleMapper("INVALID_VALUE", valueType.getInvalidValue());
+		
+		addSimpleMapper(" KEY_STRING_GENERIC_TYPE", type.isObject() ? "<String>" : "");
+		addSimpleMapper(" VALUE_STRING_GENERIC_TYPE", valueType.isObject() ? "<String>" : "");
+		addSimpleMapper(" KEY_VALUE_STRING_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<String, String>" : "<String>") : (valueType.isObject() ? "<String>" : ""));
+
+		
 		addSimpleMapper(" KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+">" : "");
 		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+", "+type.getKeyType()+">" : "");
+		addSimpleMapper(" KEY_CLASS_GENERIC_TYPE", type.isObject() ? "<"+type.getClassType()+">" : "");
+
 		
 		addSimpleMapper(" VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+">" : "");
 		addSimpleMapper(" VALUE_VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" VALUE_CLASS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getClassValueType()+">" : "");
 		
 		addSimpleMapper(" KEY_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+">" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
 		addSimpleMapper(" KEY_VALUE_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+", "+valueType.getValueType()+">" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : ""));
+		addInjectMapper(" KEY_VALUE_SPECIAL_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+", %s>" : "<"+type.getKeyType()+", %s>") : (valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>")).setBraceType("<>").removeBraces();
 		
 		addSimpleMapper(" NO_GENERIC_TYPE", type.isObject() ? "<?>" : "");
 		addSimpleMapper(" NO_KV_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
@@ -59,6 +81,10 @@ public class GlobalVariables
 		addSimpleMapper(" VALUE_SUPER_GENERIC_TYPE", valueType.isObject() ? "<? super "+valueType.getValueType()+">" : "");
 		addSimpleMapper(" KEY_VALUE_SUPER_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<? super "+type.getKeyType()+", ? super "+valueType.getValueType()+">" : "<? super "+type.getKeyType()+">") : (valueType.isObject() ? "<? super "+valueType.getValueType()+">" : ""));
 		
+		addSimpleMapper(" KEY_UNKNOWN_GENERIC_TYPE", type.isObject() ? "<? extends "+type.getKeyType()+">" : "");
+		addSimpleMapper(" VALUE_UNKNOWN_GENERIC_TYPE", valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_UNKNOWN_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<? extends "+type.getKeyType()+", ? extends "+valueType.getValueType()+">" : "<? extends "+type.getKeyType()+">") : (valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : ""));
+
 		addSimpleMapper(" KEY_ENUM_VALUE_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">, "+valueType.getValueType()+">" : "<"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">>") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
 		addSimpleMapper(" KEY_VALUE_ENUM_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<"+type.getKeyType()+", "+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : "<"+type.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : ""));
 		
@@ -83,6 +109,7 @@ public class GlobalVariables
 		addSimpleMapper(" GENERIC_KEY_VALUE_BRACES", type.isObject() ? (valueType.isObject() ? " <"+type.getKeyType()+", "+valueType.getValueType()+">" : " <"+type.getKeyType()+">") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
 		addSimpleMapper(" COMPAREABLE_KEY_BRACES", type.isObject() ? " <"+type.getKeyType()+" extends Comparable<T>>" : "");
 		addSimpleMapper("KV_BRACES", type.isObject() || valueType.isObject() ? "<>" : "");
+		addSimpleMapper("VALUE_BRACES", valueType.isObject() ? "<>" : "");
 		addSimpleMapper("BRACES", type.isObject() ? "<>" : "");
 		if(type.needsCustomJDKType())
 		{
@@ -120,6 +147,7 @@ public class GlobalVariables
 		addInjectMapper(fix+"_EQUALS_NULL", type.getComparableValue()+" == "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
 		addArgumentMapper(fix+"_EQUALS_NOT", type.getEquals(true)).removeBraces();
 		addArgumentMapper(fix+"_EQUALS", type.getEquals(false)).removeBraces();
+		addSimpleMapper("FILE_"+fix+"_TYPE", type.getFileType());
 		
 		addArgumentMapper("COMPAREABLE_TO_"+fix, type.isObject() ? "((Comparable<"+type.getKeyType(value)+">)%1$s).compareTo(("+type.getKeyType(value)+")%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
 		addArgumentMapper("COMPARE_TO_"+fix, type.isObject() ? "%1$s.compareTo(%2$s)" : type.getClassType(value)+".compare(%1$s, %2$s)").removeBraces();
@@ -135,7 +163,8 @@ public class GlobalVariables
 		addSimpleMapper("EMPTY_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])ARRAYS.EMPTY_ARRAY" : "ARRAYS.EMPTY_ARRAY");
 		addInjectMapper("NEW_"+fix+"_ARRAY", type.isObject() ? "("+fix+"_TYPE[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
 		addInjectMapper("NEW_SPECIAL_"+fix+"_ARRAY", type.isObject() ? "(E[])new Object[%s]" : "new "+fix+"_TYPE[%s]").removeBraces();
-		addInjectMapper("NEW_CLASS"+(value ? "_VALUE" : "")+"_ARRAY", type.isObject() ? "(CLASS_TYPE[])new Object[%s]" : "new CLASS_TYPE[%s]").removeBraces();
+		if(value) addInjectMapper("NEW_CLASS_VALUE_ARRAY", type.isObject() ? "(CLASS_VALUE_TYPE[])new Object[%s]" : "new CLASS_VALUE_TYPE[%s]").removeBraces();
+		else addInjectMapper("NEW_CLASS_ARRAY", type.isObject() ? "(CLASS_TYPE[])new Object[%s]" : "new CLASS_TYPE[%s]").removeBraces();
 	}
 	
 	public GlobalVariables createPreFunctions()
@@ -186,7 +215,43 @@ public class GlobalVariables
 		addClassMapper("RB_TREE_SET", "RBTreeSet");
 		addClassMapper("AVL_TREE_SET", "AVLTreeSet");
 		addClassMapper("ARRAY_SET", "ArraySet");
+		addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
 		
+		//Final UnitTest Classes
+		addAbstractMapper("MINIMAL_COLLECTION", "Minimal%sCollection");
+		addAbstractMapper("MINIMAL_SET", "Minimal%sSet");
+		addAbstractMapper("ABSTRACT_CONTAINER_TESTER", "Abstract%sContainerTester");
+		addAbstractMapper("ABSTRACT_COLLECTION_TESTER", "Abstract%sCollectionTester");
+		addAbstractMapper("ABSTRACT_QUEUE_TESTER", "Abstract%sQueueTester");
+		addAbstractMapper("ABSTRACT_LIST_INDEX_OF_TESTER", "Abstract%sListIndexOfTester");
+		addAbstractMapper("ABSTRACT_LIST_TESTER", "Abstract%sListTester");
+		addAbstractMapper("ABSTRACT_SET_TESTER", "Abstract%sSetTester");
+		addAbstractMapper("ABSTRACT_ITERATOR_TESTER", "Abstract%sIteratorTester");
+		addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
+		addClassMapper("LIST_ITERATOR_TESTER", "ListIteratorTester");
+		addClassMapper("BIDIRECTIONAL_ITERATOR_TESTER", "BidirectionalteratorTester");
+		addClassMapper("ITERATOR_TESTER", "IteratorTester");
+		addClassMapper("COLLECTION_TEST_BUILDER", "CollectionTestSuiteBuilder");
+		addClassMapper("DEQUEUE_TEST_BUILDER", "DequeueTestSuiteBuilder");
+		addClassMapper("QUEUE_TEST_BUILDER", "QueueTestSuiteBuilder");
+		addClassMapper("LIST_TEST_BUILDER", "ListTestSuiteBuilder");
+		addClassMapper("ORDERED_SET_TEST_BUILDER", "OrderedSetTestSuiteBuilder");
+		addClassMapper("SORTED_SET_TEST_BUILDER", "SortedSetTestSuiteBuilder");
+		addClassMapper("NAVIGABLE_SET_TEST_BUILDER", "NavigableSetTestSuiteBuilder");
+		addClassMapper("SET_TEST_BUILDER", "SetTestSuiteBuilder");
+		addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
+		addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
+		addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
+		addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
+		addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
+		addClassMapper("COLLECTION_CONSTRUCTOR_TESTS", "CollectionConstructorTests");
+		addClassMapper("SUB_SORTED_SET_CLASS_GENERATOR", "SortedSetSubsetTestSetGenerator");
+		addClassMapper("SUB_NAVIGABLE_SET_CLASS_GENERATOR", "NavigableSetSubsetTestSetGenerator");
+		addClassMapper("LIST_TESTS", "ListTests");
+		addClassMapper("SET_TESTS", "SetTests");
+		addClassMapper("QUEUE_TESTS", "QueueTests");
+		addBiClassMapper("MAP_TESTS", "MapTests", "2");
+
 		//Abstract Classes
 		addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
 		addAbstractMapper("ABSTRACT_PRIORITY_QUEUE", "Abstract%sPriorityQueue");
@@ -206,6 +271,24 @@ public class GlobalVariables
 		addClassMapper("ITERATORS", "Iterators");
 		addClassMapper("ITERABLES", "Iterables");
 		addBiClassMapper("MAPS", "Maps", "2");
+		addClassMapper("SAMPLE_ELEMENTS", "Samples");
+		
+		//UnitTest Helper Classes
+		addClassMapper("HELPERS", "Helpers");
+		addAbstractMapper("TEST_COLLECTION_GENERATOR", "Test%sCollectionGenerator");
+		addAbstractMapper("TEST_QUEUE_GENERATOR", "Test%sQueueGenerator");
+		addAbstractMapper("TEST_LIST_GENERATOR", "Test%sListGenerator");
+		addAbstractMapper("TEST_NAVIGABLE_SET_GENERATOR", "Test%sNavigableSetGenerator");
+		addAbstractMapper("TEST_SORTED_SET_GENERATOR", "Test%sSortedSetGenerator");
+		addAbstractMapper("TEST_ORDERED_SET_GENERATOR", "Test%sOrderedSetGenerator");
+		addAbstractMapper("TEST_SET_GENERATOR", "Test%sSetGenerator");
+		addAbstractMapper("SIMPLE_TEST_GENERATOR", "Simple%sTestGenerator");
+		addAbstractMapper("SIMPLE_QUEUE_TEST_GENERATOR", "Simple%sQueueTestGenerator");
+		addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
+		addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
+		addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
+		addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
+		addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
 		
 		//Interfaces
 		addClassMapper("LIST_ITERATOR", "ListIterator");
@@ -245,7 +328,6 @@ public class GlobalVariables
 			if(!valueType.isObject()) addSimpleMapper("VALUE_CONSUMER", valueType.getFileType()+"Consumer");
 			else addSimpleMapper("VALUE_CONSUMER", "Consumer");
 			addSimpleMapper("CONSUMER", "Consumer");
-			addSimpleMapper("COMPARATOR", "Comparator");	
 			addSimpleMapper("IARRAY", "IObjectArray");
 		}
 		else
@@ -256,9 +338,10 @@ public class GlobalVariables
 				addSimpleMapper("CONSUMER", type.getFileType()+"Consumer");
 			}
 			else addClassMapper("CONSUMER", "Consumer");
-			addClassMapper("COMPARATOR", "Comparator");
 			addFunctionMappers("IARRAY", "I%sArray");
 		}
+		addSimpleMapper("VALUE_COMPARATOR", valueType.isObject() ? "Comparator" : String.format("%sComparator", valueType.getNonFileType()));
+		addSimpleMapper("COMPARATOR", type.isObject() ? "Comparator" : String.format("%sComparator", type.getNonFileType()));
 		return this;
 	}
 	
@@ -308,6 +391,7 @@ public class GlobalVariables
 		addSimpleMapper("VALUE_TEST_VALUE", valueType.isObject() ? "getBoolean" : "get");
 		addSimpleMapper("TEST_VALUE", type.isObject() ? "getBoolean" : "get");
 		addSimpleMapper("NEW_STREAM", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getKeyType()+"Stream");
+		addSimpleMapper("VALUE_TO_ARRAY", "to"+valueType.getNonFileType()+"Array");
 		addSimpleMapper("TO_ARRAY", "to"+type.getNonFileType()+"Array");
 		addSimpleMapper("[SPACE]", " ");
 		return this;

src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java

@@ -6,6 +6,8 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -14,6 +16,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.StringJoiner;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 import speiger.src.builder.processor.TemplateProcess;
@@ -23,6 +26,7 @@ import speiger.src.builder.processor.TemplateProcessor;
 public class PrimitiveCollectionsBuilder extends TemplateProcessor
 {
 	Map<String, EnumSet<ClassType>> blocked = new HashMap<>();
+	EnumMap<ClassType, List<Predicate<String>>> blockedPredicate = new EnumMap<>(ClassType.class);
 	Map<String, String> nameRemapper = new HashMap<>();
 	Map<String, String> biRequired = new HashMap<>();
 	Set<String> enumRequired = new HashSet<>();
@@ -30,6 +34,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	List<GlobalVariables> variables = new ArrayList<>();
 	List<GlobalVariables> biVariables = new ArrayList<>();
 	List<GlobalVariables> enumVariables = new ArrayList<>();
+	boolean special = false;
 	
 	public PrimitiveCollectionsBuilder()
 	{
@@ -51,6 +56,19 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
 	}
 	
+	private PrimitiveCollectionsBuilder setSpecial() {
+		special = true;
+		return this;
+	}
+	
+	private static PrimitiveCollectionsBuilder createTests(boolean silent) {
+		return new PrimitiveCollectionsBuilder(silent, Paths.get("src/builder/resources/speiger/assets/tests/templates/"), Paths.get("src/test/java/speiger/src/tests/"), Paths.get("src/builder/resources/speiger/assets/tests/")).setSpecial();
+	}
+	
+	private static PrimitiveCollectionsBuilder createTesters(boolean silent) {
+		return new PrimitiveCollectionsBuilder(silent, Paths.get("src/builder/resources/speiger/assets/testers/templates/"), Paths.get("src/test/java/speiger/src/testers/"), Paths.get("src/builder/resources/speiger/assets/testers/")).setSpecial();
+	}
+	
 	@Override
 	protected boolean isFileValid(Path fileName)
 	{
@@ -72,7 +90,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	@Override
 	protected void afterFinish()
 	{
-		if(getVersion() > 8) 
+		if(!special && getVersion() > 8) 
 		{
 			Path basePath = Paths.get("src/main/java");
 			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
@@ -119,9 +137,50 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		nameRemapper.put("ImmutableOpenHashSet", "Immutable%sOpenHashSet");
 		nameRemapper.put("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
 		
+		
 		addBlockage(ClassType.OBJECT, "Consumer", "Comparator", "Stack");
 		addBlockage(ClassType.BOOLEAN, "ArraySet", "AVLTreeSet", "RBTreeSet", "SortedSet", "OrderedSet", "NavigableSet", "OpenHashSet", "OpenCustomHashSet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
 		addBlockage(ClassType.BOOLEAN, "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "ImmutableOpenHashSet", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
+		
+		//UnitTesters
+		nameRemapper.put("AbstractIteratorTester", "Abstract%sIteratorTester");
+		nameRemapper.put("MinimalCollection", "Minimal%sCollection");
+		nameRemapper.put("MinimalSet", "Minimal%sSet");
+		nameRemapper.put("TestCollectionGenerator", "Test%sCollectionGenerator");
+		nameRemapper.put("TestQueueGenerator", "Test%sQueueGenerator");
+		nameRemapper.put("TestListGenerator", "Test%sListGenerator");
+		nameRemapper.put("TestNavigableSetGenerator", "Test%sNavigableSetGenerator");
+		nameRemapper.put("TestSortedSetGenerator", "Test%sSortedSetGenerator");
+		nameRemapper.put("TestOrderedSetGenerator", "Test%sOrderedSetGenerator");
+		nameRemapper.put("TestSetGenerator", "Test%sSetGenerator");
+		nameRemapper.put("AbstractContainerTester", "Abstract%sContainerTester");
+		nameRemapper.put("AbstractCollectionTester", "Abstract%sCollectionTester");
+		nameRemapper.put("AbstractQueueTester", "Abstract%sQueueTester");
+		nameRemapper.put("AbstractListTester", "Abstract%sListTester");
+		nameRemapper.put("AbstractListIndexOfTester", "Abstract%sListIndexOfTester");
+		nameRemapper.put("AbstractSetTester", "Abstract%sSetTester");
+		nameRemapper.put("SimpleTestGenerator", "Simple%sTestGenerator");
+		nameRemapper.put("SimpleQueueTestGenerator", "Simple%sQueueTestGenerator");
+		nameRemapper.put("TestMapGenerator", "Test%sMapGenerator");
+		nameRemapper.put("TestSortedMapGenerator", "Test%sSortedMapGenerator");
+		nameRemapper.put("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
+		nameRemapper.put("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
+		nameRemapper.put("DerivedMapGenerators", "Derived%sMapGenerators");
+		nameRemapper.put("AbstractMapTester", "Abstract%sMapTester");
+		nameRemapper.put("TestMap", "Test%sMap");
+		biRequired.put("PairTester", "");
+		
+		addBiClass("TestMapGenerator", "TestSortedMapGenerator", "TestOrderedMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester", "MapTestSuiteBuilder", "SortedMapTestSuiteBuilder", "NavigableMapTestSuiteBuilder", "OrderedMapTestSuiteBuilder", "MapTests", "MapConstructorTests", "TestMap");
+		addBiClass("MapAddToTester", "MapSubFromTester", "MapClearTester", "MapComputeIfAbsentTester", "MapComputeIfPresentTester", "MapComputeTester", "MapCopyTester", "MapContainsTester", "MapContainsKeyTester", "MapContainsValueTester", "MapCreatorTester", "MapEntrySetTester",
+			"MapEqualsTester", "MapForEachTester", "MapGetOrDefaultTester", "MapGetTester", "MapHashCodeTester", "MapIsEmptyTester", "MapMergeTester", "MapMergeBulkTester", "MapPutAllArrayTester", "MapPutAllTester", "MapPutIfAbsentTester", "MapPutTester",
+			"MapRemoveEntryTester", "MapRemoveOrDefaultTester", "MapRemoveTester", "MapReplaceAllTester", "MapReplaceEntryTester", "MapReplaceTester", "MapSizeTester", "MapSupplyIfAbsentTester", "MapToStringTester",
+			"NavigableMapNavigationTester", "SortedMapNavigationTester", "OrderedMapNavigationTester", "OrderedMapMoveTester", "MapConstructorTester");
+		
+		addBlockage(ClassType.OBJECT, "CollectionStreamTester", "ListFillBufferTester");
+		addBlockage(ClassType.BOOLEAN, "TestOrderedSetGenerator", "TestSortedSetGenerator", "TestNavigableSetGenerator", "CollectionRemoveIfTester", "CollectionStreamTester", "ListFillBufferTester", "ListReplaceAllTester", "NavigableSetNavigationTester", "SetTests", "MapConstructorTests", "TestMap", "QueueTests");
+		addBlockage(ClassType.BOOLEAN, "OrderedSetMoveTester", "OrderedSetNavigationTester", "SortedSetNaviationTester", "SetTestSuiteBuilder", "OrderedSetTestSuiteBuilder", "SortedSetTestSuiteBuilder", "NavigableSetTestSuiteBuilder", "SortedSetSubsetTestSetGenerator", "OrderedMapNavigationTester", "OrderedMapTestSuiteBuilder", "OrderedSetIterationTester", "SortedSetIterationTester");
+		addBlockage(ClassType.BOOLEAN, "TestMapGenerator", "TestSortedMapGenerator", "TestOrderedMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester", "MapTestSuiteBuilder", "SortedMapTestSuiteBuilder", "NavigableMapTestSuiteBuilder", "MapTests");
+		addBlockage(ClassType.BOOLEAN, T -> T.endsWith("Tester") && (T.startsWith("Iterable") ||T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
 	}
 	
 	protected void create(ClassType mainType, ClassType subType) 
@@ -146,6 +205,11 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		}
 	}
 	
+	protected void addBlockage(ClassType type, Predicate<String> filter)
+	{
+		blockedPredicate.computeIfAbsent(type, T -> new ArrayList<>()).add(filter);
+	}
+	
 	protected void addBlockage(ClassType type, String...args) 
 	{
 		for(String s : args) 
@@ -166,17 +230,29 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		String splitter = biRequired.get(name);
 		boolean valueRequired = enumRequired.contains(name);
 		List<GlobalVariables> vars = getVariablesByClass(name, splitter != null);
-		EnumSet<ClassType> types = blocked.get(name);
 		for(int i = 0,m=vars.size();i<m;i++)
 		{
 			GlobalVariables type = vars.get(i);
-			if(types == null || !types.contains(type.getType()))
+			if(isAllowed(type.getType(), name))
 			{
 				acceptor.accept(type.create(nameRemapper.getOrDefault(name, "%s"+name), splitter, valueRequired));
 			}
 		}
 	}
 	
+	protected boolean isAllowed(ClassType type, String fileName)
+	{
+		EnumSet<ClassType> types = blocked.get(fileName);
+		if(types != null && types.contains(type)) return false;
+		List<Predicate<String>> list = blockedPredicate.get(type);
+		if(list != null) {
+			for(int i = 0,m=list.size();i<m;i++) {
+				if(list.get(i).test(fileName)) return false;
+			}
+		}
+		return true;
+	}
+	
 	protected List<GlobalVariables> getVariablesByClass(String name, boolean bi) {
 		if(enumRequired.contains(name)) return enumVariables;
 		if(bi) return biVariables;
@@ -236,28 +312,19 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	{
 		try
 		{
-	        if(args.length == 0) {
-	            new PrimitiveCollectionsBuilder().process(false);
-	        } else if(args.length == 1) {
-	            new PrimitiveCollectionsBuilder().process(Boolean.parseBoolean(args[0]));
-	        } else if(args.length == 2) {
-	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[1])).process(Boolean.parseBoolean(args[0]));
-	        } else if(args.length == 3) {
-	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(false);
-	        } else if(args.length == 4) {
-	            new PrimitiveCollectionsBuilder(false, Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
-	        } else if(args.length == 4) {
-	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[4]), Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
-	        } else {
-	            System.out.println("Invalid argument count passed in");
-	            System.exit(1);
-	    	}
-		}
-		catch(InterruptedException e)
-		{
-			e.printStackTrace();
-		}
-		catch(IOException e)
+			Set<String> flags = new HashSet<>(Arrays.asList(args));
+			boolean silent = flags.contains("silent");
+			boolean force = flags.contains("force");
+			boolean tests = flags.contains("tests");
+			boolean forceTests =  flags.contains("force-tests");
+			
+            new PrimitiveCollectionsBuilder(silent).process(force);
+            if(tests) {
+    			createTests(silent).process(force || forceTests);
+    			createTesters(silent).process(force || forceTests);
+            }
+        }
+		catch(InterruptedException | IOException e)
 		{
 			e.printStackTrace();
 		}

src/builder/resources/speiger/assets/testers/templates/builder/CollectionTestSuiteBuilder.template

@@ -0,0 +1,91 @@
+package speiger.src.testers.PACKAGE.builder;
+
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.CollectionTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.testers.CollectionRemoveIfTester;
+
+import speiger.src.testers.base.tests.collection.JavaCollectionRemoveIfTester;
+import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionAddAllArrayTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionAddAllTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionAddTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionClearTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionContainsAllTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionContainsAnyTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionContainsTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionCopyTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionEqualsTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionForEachTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionIteratorTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionRemoveAllTester;
+#if !TYPE_BOOLEAN
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionRemoveIfTester;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionStreamTester;
+#endif
+#endif
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionRetainAllTester;
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionToArrayTester;
+#if !TYPE_BOOLEAN
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableCountTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableDistinctTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableFilterTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableFindFirstTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableLimitTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableMapTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableMatchesTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterablePeekTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableReduceTester;
+import speiger.src.testers.PACKAGE.tests.iterable.FILE_KEY_TYPEIterableSortedTester;
+#endif
+
+@SuppressWarnings("javadoc")
+public class COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE extends CollectionTestSuiteBuilder<CLASS_TYPE> {
+	public static GENERIC_KEY_BRACES COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE) new COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		testers.remove(CollectionRemoveIfTester.class);
+		testers.add(JavaCollectionRemoveIfTester.class);
+#if !TYPE_BOOLEAN
+		testers.add(FILE_KEY_TYPEIterableMapTester.class);
+		testers.add(FILE_KEY_TYPEIterableFilterTester.class);
+		testers.add(FILE_KEY_TYPEIterableDistinctTester.class);
+		testers.add(FILE_KEY_TYPEIterableLimitTester.class);
+		testers.add(FILE_KEY_TYPEIterableSortedTester.class);
+		testers.add(FILE_KEY_TYPEIterableMatchesTester.class);
+		testers.add(FILE_KEY_TYPEIterablePeekTester.class);
+		testers.add(FILE_KEY_TYPEIterableReduceTester.class);
+		testers.add(FILE_KEY_TYPEIterableCountTester.class);
+		testers.add(FILE_KEY_TYPEIterableFindFirstTester.class);
+#endif
+		testers.add(FILE_KEY_TYPECollectionAddAllTester.class);
+		testers.add(FILE_KEY_TYPECollectionAddAllArrayTester.class);
+		testers.add(FILE_KEY_TYPECollectionAddTester.class);
+		testers.add(FILE_KEY_TYPECollectionClearTester.class);
+		testers.add(FILE_KEY_TYPECollectionContainsAllTester.class);
+		testers.add(FILE_KEY_TYPECollectionContainsAnyTester.class);
+		testers.add(FILE_KEY_TYPECollectionContainsTester.class);
+		testers.add(FILE_KEY_TYPECollectionCopyTester.class);
+		testers.add(FILE_KEY_TYPECollectionEqualsTester.class);
+		testers.add(FILE_KEY_TYPECollectionForEachTester.class);
+		testers.add(FILE_KEY_TYPECollectionIteratorTester.class);
+		testers.add(FILE_KEY_TYPECollectionRemoveAllTester.class);
+		testers.add(FILE_KEY_TYPECollectionRetainAllTester.class);
+#if !TYPE_BOOLEAN
+		testers.add(FILE_KEY_TYPECollectionRemoveIfTester.class);
+#if !TYPE_OBJECT
+		testers.add(FILE_KEY_TYPECollectionStreamTester.class);
+#endif
+#endif
+		testers.add(FILE_KEY_TYPECollectionToArrayTester.class);
+		return testers;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/DequeueTestSuiteBuilder.template

@@ -0,0 +1,28 @@
+package speiger.src.testers.PACKAGE.builder;
+
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueDequeueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueEnqueueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEDequeueLastTester;
+
+@SuppressWarnings("javadoc")
+public class DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends QUEUE_TEST_BUILDER KEY_GENERIC_TYPE
+{
+	public static GENERIC_KEY_BRACES DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
+		return (DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE)new DEQUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> tester = super.getTesters();
+		tester.add(FILE_KEY_TYPEDequeueDequeueTester.class);
+		tester.add(FILE_KEY_TYPEDequeueEnqueueTester.class);
+		tester.add(FILE_KEY_TYPEDequeueLastTester.class);
+		return tester;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/ListTestSuiteBuilder.template

@@ -0,0 +1,384 @@
+package speiger.src.testers.PACKAGE.builder;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
+#endignore
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.ListTestSuiteBuilder;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.TestListGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
+import com.google.common.collect.testing.testers.ListAddAllAtIndexTester;
+import com.google.common.collect.testing.testers.ListAddAllTester;
+import com.google.common.collect.testing.testers.ListAddAtIndexTester;
+import com.google.common.collect.testing.testers.ListAddTester;
+import com.google.common.collect.testing.testers.ListCreationTester;
+import com.google.common.collect.testing.testers.ListEqualsTester;
+import com.google.common.collect.testing.testers.ListGetTester;
+import com.google.common.collect.testing.testers.ListHashCodeTester;
+import com.google.common.collect.testing.testers.ListIndexOfTester;
+import com.google.common.collect.testing.testers.ListLastIndexOfTester;
+import com.google.common.collect.testing.testers.ListRemoveAllTester;
+import com.google.common.collect.testing.testers.ListRemoveAtIndexTester;
+import com.google.common.collect.testing.testers.ListRemoveTester;
+import com.google.common.collect.testing.testers.ListReplaceAllTester;
+import com.google.common.collect.testing.testers.ListRetainAllTester;
+import com.google.common.collect.testing.testers.ListSetTester;
+import com.google.common.collect.testing.testers.ListSubListTester;
+import com.google.common.collect.testing.testers.ListToArrayTester;
+import com.google.common.testing.SerializableTester;
+
+import junit.framework.TestSuite;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.base.tests.list.JavaListListIteratorTester;
+import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAbsentTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllArrayAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllListAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListAddTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListCreationTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListEqualsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListExtractElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListGetTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListIndexOfTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListLastIndexOfTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListListIteratorTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListPresentTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveElementsTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRemoveTester;
+#if !TYPE_BOOLEAN
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSortTester;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListFillBufferTester;
+#endif
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListReplaceAllTester;
+#endif
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListRetainAllTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSetTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSubListTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveAtIndexTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListSwapRemoveTester;
+import speiger.src.testers.PACKAGE.tests.list.FILE_KEY_TYPEListToArrayTester;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+#if !TYPE_BOOLEAN
+import speiger.src.testers.utils.SpecialFeature;
+#endif
+
+@SuppressWarnings("javadoc")
+public class LIST_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
+	
+#if TYPE_OBJECT
+	KEY_TYPE[] prefixes;
+	KEY_TYPE[] suffixes;
+#else
+	KEY_TYPE[] prefixes = createPrefixes();
+	KEY_TYPE[] suffixes = createSuffixes();
+#endif
+	
+	public static GENERIC_KEY_BRACES LIST_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (LIST_TEST_BUILDER KEY_GENERIC_TYPE) new LIST_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setPrefixes(KEY_TYPE[] prefixes) {
+		this.prefixes = prefixes;
+		return this;
+	}
+	
+	public LIST_TEST_BUILDER KEY_GENERIC_TYPE setSuffixes(KEY_TYPE[] suffixes) {
+		this.suffixes = suffixes;
+		return this;
+	}
+	
+#if !TYPE_OBJECT
+	public KEY_TYPE[] createPrefixes() {
+#if TYPE_BOOLEAN
+		return new KEY_TYPE[]{false, false, false};
+#else if TYPE_BYTE
+		return new KEY_TYPE[]{(byte)-3, (byte)-2, (byte)-1};
+#else if TYPE_SHORT
+		return new KEY_TYPE[]{(short)-3, (short)-2, (short)-1};
+#else if TYPE_CHAR
+		return new KEY_TYPE[]{'^', '_', '`'};
+#else
+		return new KEY_TYPE[]{-3, -2, -1};
+#endif
+	}
+	
+	public KEY_TYPE[] createSuffixes() {
+#if TYPE_BOOLEAN
+		return new KEY_TYPE[]{true, true, true};
+#else if TYPE_BYTE
+		return new KEY_TYPE[]{(byte)5, (byte)6, (byte)7};
+#else if TYPE_SHORT
+		return new KEY_TYPE[]{(short)5, (short)6, (short)7};
+#else if TYPE_CHAR
+		return new KEY_TYPE[]{'f', 'g', 'h'};
+#else
+		return new KEY_TYPE[]{5, 6, 7};
+#endif
+	}
+	
+#endif
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+
+		testers.add(CollectionSerializationEqualTester.class);
+		testers.add(ListAddAllAtIndexTester.class);
+		testers.add(ListAddAllTester.class);
+		testers.add(ListAddAtIndexTester.class);
+		testers.add(ListAddTester.class);
+		testers.add(ListCreationTester.class);
+		testers.add(ListEqualsTester.class);
+		testers.add(ListGetTester.class);
+		testers.add(ListHashCodeTester.class);
+		testers.add(ListIndexOfTester.class);
+		testers.add(ListLastIndexOfTester.class);
+		testers.add(JavaListListIteratorTester.class);
+		testers.add(ListRemoveAllTester.class);
+		testers.add(ListRemoveAtIndexTester.class);
+		testers.add(ListRemoveTester.class);
+		testers.add(ListReplaceAllTester.class);
+		testers.add(ListRetainAllTester.class);
+		testers.add(ListSetTester.class);
+		testers.add(ListSubListTester.class);
+		testers.add(ListToArrayTester.class);
+		
+		testers.add(FILE_KEY_TYPEListAddAllAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllListAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllArrayAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddAllTester.class);
+		testers.add(FILE_KEY_TYPEListAddAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListAddTester.class);
+		testers.add(FILE_KEY_TYPEListAbsentTester.class);
+		testers.add(FILE_KEY_TYPEListPresentTester.class);
+		testers.add(FILE_KEY_TYPEListCreationTester.class);
+		testers.add(FILE_KEY_TYPEListEqualsTester.class);
+		testers.add(FILE_KEY_TYPEListGetTester.class);
+		testers.add(FILE_KEY_TYPEListGetElementsTester.class);
+		testers.add(FILE_KEY_TYPEListExtractElementsTester.class);
+		testers.add(FILE_KEY_TYPEListIndexOfTester.class);
+		testers.add(FILE_KEY_TYPEListLastIndexOfTester.class);
+		testers.add(FILE_KEY_TYPEListListIteratorTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveAllTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveTester.class);
+		testers.add(FILE_KEY_TYPEListRemoveElementsTester.class);
+		testers.add(FILE_KEY_TYPEListSwapRemoveAtIndexTester.class);
+		testers.add(FILE_KEY_TYPEListSwapRemoveTester.class);
+#if !TYPE_BOOLEAN
+		testers.add(FILE_KEY_TYPEListSortTester.class);
+#if !TYPE_OBJECT
+		testers.add(FILE_KEY_TYPEListFillBufferTester.class);
+#endif
+		testers.add(FILE_KEY_TYPEListReplaceAllTester.class);
+#endif
+		testers.add(FILE_KEY_TYPEListRetainAllTester.class);
+		testers.add(FILE_KEY_TYPEListSetTester.class);
+		testers.add(FILE_KEY_TYPEListSubListTester.class);
+		testers.add(FILE_KEY_TYPEListToArrayTester.class);
+		return testers;
+	}
+
+	@Override
+	public TestSuite createTestSuite() {
+#ignore
+		withFeatures(KNOWN_ORDER);
+#endignore
+		return super.createTestSuite();
+	}
+
+	@Override
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+#ignore
+		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
+#endignore
+			derivedSuites.add(ListTestSuiteBuilder.using(new ReserializedListGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
+							.named(getName() + " reserialized")
+							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
+							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+		}
+#ignore
+		if(!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
+#endignore
+#if !TYPE_BOOLEAN
+			if(prefixes != null) {
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, null))
+						.named(getName() + " subSet_prefix")
+						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+			}
+			if(suffixes != null) {
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), null, suffixes))
+					.named(getName() + " subSet_suffixes")
+					.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+					.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+					.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+			}
+			if(prefixes != null && suffixes != null) {
+				derivedSuites.add(LIST_TEST_BUILDER.using(new SubListListGeneratorBRACES(parentBuilder.getSubjectGenerator(), prefixes, suffixes))
+						.named(getName() + " subSet")
+						.withFeatures(computeSubListFeatures(parentBuilder.getFeatures()))
+						.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+			}
+#endif
+		}
+		return derivedSuites;
+	}
+	
+	static class SubListListGenerator KEY_GENERIC_TYPE implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE {
+		TEST_LIST_GENERATOR KEY_GENERIC_TYPE generator;
+		KEY_TYPE[] prefix;
+		KEY_TYPE[] suffix;
+		
+		public SubListListGenerator(OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE> gen, KEY_TYPE[] prefix, KEY_TYPE[] suffix) {
+			generator = (TEST_LIST_GENERATOR KEY_GENERIC_TYPE)gen.getInnerGenerator();
+			this.prefix = prefix;
+			this.suffix = suffix;
+		}
+		
+		@Override
+		public SampleElements<CLASS_TYPE> samples() {
+			return generator.samples();
+		}
+		
+		@Override
+		public CLASS_TYPE[] createArray(int length) {
+			return generator.createArray(length);
+		}
+		
+		@Override
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+			return generator.order(insertionOrder);
+		}
+		
+		@Override
+		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+			return generator.getSamples();
+		}
+		
+		@Override
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+			return generator.order(insertionOrder);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public LIST 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);
+		}
+		
+		@Override
+		public LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			int length = getLength(prefix);
+			return generator.create(merge(elements)).subList(length, length+elements.length);
+		}
+		
+#else
+		@Override
+		public LIST 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);
+			}
+			int length = getLength(prefix);
+			return generator.create(merge(array)).subList(length, length+elements.length);
+		}
+		
+#endif
+		private int getLength(KEY_TYPE[] keys) {
+			return keys == null ? 0 : keys.length;
+		}
+		
+		private KEY_TYPE[] merge(KEY_TYPE[] input) {
+			int prefixLength = getLength(prefix);
+			int suffixLength = getLength(suffix);
+			KEY_TYPE[] result = NEW_KEY_ARRAY(input.length+prefixLength+suffixLength);
+			if(prefixLength != 0) System.arraycopy(prefix, 0, result, 0, prefixLength);
+			System.arraycopy(input, 0, result, prefixLength, input.length);
+			if(suffixLength != 0) System.arraycopy(suffix, 0, result, prefixLength+input.length, suffixLength);
+			return result;
+		}
+	}
+	
+	static class ReserializedListGenerator<E> implements TestListGenerator<E> {
+		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
+
+		private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
+			this.gen = gen;
+		}
+
+		@Override
+		public SampleElements<E> samples() {
+			return gen.samples();
+		}
+
+		@Override
+		public List<E> create(Object... elements) {
+			return (List<E>) SerializableTester.reserialize(gen.create(elements));
+		}
+
+		@Override
+		public E[] createArray(int length) {
+			return gen.createArray(length);
+		}
+
+		@Override
+		public Iterable<E> order(List<E> insertionOrder) {
+			return gen.order(insertionOrder);
+		}
+	}
+	
+#if !TYPE_BOOLEAN
+	private static Set<Feature<?>> computeSubListFeatures(Set<Feature<?>> features) {
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+#ignore
+		derivedFeatures.add(CollectionFeature.SUBSET_VIEW);
+		derivedFeatures.remove(SpecialFeature.COPYING);
+		derivedFeatures.remove(SpecialFeature.CHILDREN_COPY);
+#endignore
+		return derivedFeatures;
+	}
+
+#endif
+	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+#ignore
+		derivedFeatures.remove(SERIALIZABLE);
+		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
+#endignore
+		return derivedFeatures;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/NavigableSetTestSuiteBuilder.template

@@ -0,0 +1,140 @@
+package speiger.src.testers.PACKAGE.builder;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.DESCENDING_VIEW;
+import static com.google.common.collect.testing.features.CollectionFeature.SUBSET_VIEW;
+#endignore
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.testers.NavigableSetNavigationTester;
+
+import junit.framework.TestSuite;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+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.utils.LISTS;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR.SUB_NAVIGABLE_SET_CLASS_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPENavigableSetNavigationTester;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.utils.SpecialFeature;
+
+@SuppressWarnings("javadoc")
+public class NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE {
+	public static GENERIC_KEY_BRACES NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE) new NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		testers.add(NavigableSetNavigationTester.class);
+		testers.add(FILE_KEY_TYPENavigableSetNavigationTester.class);
+		return testers;
+	}
+	
+	@Override
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+
+#ignore
+		if (!parentBuilder.getFeatures().contains(SUBSET_VIEW)) {
+#endignore
+			// Other combinations are inherited from SortedSetTestSuiteBuilder.
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
+		}
+#ignore
+		if (!parentBuilder.getFeatures().contains(DESCENDING_VIEW)) {
+#endignore
+			derivedSuites.add(createDescendingSuite(parentBuilder));
+		}
+		return derivedSuites;
+	}
+
+	@Override
+	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+	    return NAVIGABLE_SET_TEST_BUILDER.using(new SUB_NAVIGABLE_SET_CLASS_GENERATORBRACES(delegate, to, from));
+	}
+	
+	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+		TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+
+		List<Feature<?>> features = new ArrayList<>();
+#ignore
+		features.add(DESCENDING_VIEW);
+		features.addAll(parentBuilder.getFeatures());
+		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.CHILDREN_COPY);
+#endignore
+
+		return NAVIGABLE_SET_TEST_BUILDER.using(new TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE() {
+
+			@Override
+			public SampleElements<CLASS_TYPE> samples() {
+				return delegate.samples();
+			}
+			
+			@Override
+			public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+				return delegate.getSamples();
+			}
+
+			@Override
+			public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+				delegate.order(insertionOrder).forEach(list::add);
+				LISTS.reverse(list);
+				return list;
+			}
+
+			@Override
+			public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+				LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+				for(CLASS_TYPE entry : delegate.order(insertionOrder))
+				{
+					list.add(OBJ_TO_KEY(entry));
+				}
+				LISTS.reverse(list);
+				return list;
+			}
+			@Override
+			public KEY_TYPE belowSamplesLesser() { return delegate.aboveSamplesGreater(); }
+			@Override
+			public KEY_TYPE belowSamplesGreater() { return delegate.aboveSamplesLesser(); }
+			@Override
+			public KEY_TYPE aboveSamplesLesser() { return delegate.belowSamplesGreater(); }
+			@Override
+			public KEY_TYPE aboveSamplesGreater() { return delegate.belowSamplesLesser(); }
+			
+#if !TYPE_OBJECT
+			@Override
+			public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+				return delegate.create(elements).descendingSet();
+			}
+
+#endif
+			@Override
+			public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
+				return delegate.create(elements).descendingSet();
+			}
+		}).named(parentBuilder.getName() + " descending").withFeatures(features)
+				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template

@@ -0,0 +1,38 @@
+package speiger.src.testers.PACKAGE.builder;
+
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import junit.framework.TestSuite;
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetMoveTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetIterationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetNavigationTester;
+
+@SuppressWarnings("javadoc")
+public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
+	public static GENERIC_KEY_BRACES ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		testers.add(FILE_KEY_TYPEOrderedSetNavigationTester.class);
+		testers.add(FILE_KEY_TYPEOrderedSetMoveTester.class);
+		testers.add(FILE_KEY_TYPEOrderedSetIterationTester.class);
+		return testers;
+	}
+	
+	@Override
+	public TestSuite createTestSuite() {
+#ignore
+		withFeatures(CollectionFeature.KNOWN_ORDER);
+#endignore
+		return super.createTestSuite();
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/QueueTestSuiteBuilder.template

@@ -0,0 +1,60 @@
+package speiger.src.testers.PACKAGE.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.PerCollectionSizeTestSuiteBuilder;
+
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueDequeueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueEnqueueTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueFirstTester;
+import speiger.src.testers.PACKAGE.tests.queue.FILE_KEY_TYPEQueueRemoveTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueCountTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueDistinctTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFilterTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueFindFirstTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueLimitTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMapTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueMatchesTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueuePeekTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueForEachTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueReduceTester;
+import speiger.src.testers.PACKAGE.tests.queue.iterators.FILE_KEY_TYPEQueueSortedTester;
+
+@SuppressWarnings("javadoc")
+public class QUEUE_TEST_BUILDER KEY_GENERIC_TYPE extends PerCollectionSizeTestSuiteBuilder<QUEUE_TEST_BUILDER KEY_GENERIC_TYPE, TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE, PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
+{
+	public static GENERIC_KEY_BRACES QUEUE_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE builder) {
+		return new QUEUE_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(builder);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters()
+	{
+		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
+		testers.add(FILE_KEY_TYPEQueueEnqueueTester.class);
+		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
+		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueRemoveTester.class);
+		testers.add(FILE_KEY_TYPEQueueCountTester.class);
+		testers.add(FILE_KEY_TYPEQueueCountTester.class);
+		testers.add(FILE_KEY_TYPEQueueDequeueTester.class);
+		testers.add(FILE_KEY_TYPEQueueDistinctTester.class);
+		testers.add(FILE_KEY_TYPEQueueFilterTester.class);
+		testers.add(FILE_KEY_TYPEQueueFindFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueFirstTester.class);
+		testers.add(FILE_KEY_TYPEQueueLimitTester.class);
+		testers.add(FILE_KEY_TYPEQueueMapTester.class);
+		testers.add(FILE_KEY_TYPEQueueMatchesTester.class);
+		testers.add(FILE_KEY_TYPEQueuePeekTester.class);
+		testers.add(FILE_KEY_TYPEQueueForEachTester.class);
+		testers.add(FILE_KEY_TYPEQueueReduceTester.class);
+		testers.add(FILE_KEY_TYPEQueueSortedTester.class);
+		return testers;
+	}
+	
+}

src/builder/resources/speiger/assets/testers/templates/builder/SetTestSuiteBuilder.template

@@ -0,0 +1,116 @@
+package speiger.src.testers.PACKAGE.builder;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE;
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
+#endignore
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.SetTestSuiteBuilder;
+import com.google.common.collect.testing.TestSetGenerator;
+import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
+import com.google.common.collect.testing.testers.SetAddAllTester;
+import com.google.common.collect.testing.testers.SetAddTester;
+import com.google.common.collect.testing.testers.SetCreationTester;
+import com.google.common.collect.testing.testers.SetEqualsTester;
+import com.google.common.collect.testing.testers.SetHashCodeTester;
+import com.google.common.collect.testing.testers.SetRemoveTester;
+import com.google.common.testing.SerializableTester;
+
+import junit.framework.TestSuite;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddAllTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetAddTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetCreationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetEqualsTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESetRemoveTester;
+
+@SuppressWarnings("javadoc")
+public class SET_TEST_BUILDER KEY_GENERIC_TYPE extends COLLECTION_TEST_BUILDER KEY_GENERIC_TYPE {
+	public static GENERIC_KEY_BRACES SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (SET_TEST_BUILDER KEY_GENERIC_TYPE) new SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+	    testers.add(CollectionSerializationEqualTester.class);
+	    testers.add(SetAddAllTester.class);
+	    testers.add(SetAddTester.class);
+	    testers.add(SetCreationTester.class);
+	    testers.add(SetHashCodeTester.class);
+	    testers.add(SetEqualsTester.class);
+	    testers.add(SetRemoveTester.class);
+	    
+		testers.add(FILE_KEY_TYPESetAddAllTester.class);
+		testers.add(FILE_KEY_TYPESetAddTester.class);
+		testers.add(FILE_KEY_TYPESetCreationTester.class);
+		testers.add(FILE_KEY_TYPESetEqualsTester.class);
+		testers.add(FILE_KEY_TYPESetRemoveTester.class);
+		return testers;
+	}
+	
+	@Override
+	protected List<TestSuite> createDerivedSuites(
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+		List<TestSuite> derivedSuites = new ArrayList<>(super.createDerivedSuites(parentBuilder));
+
+		if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
+			derivedSuites.add(SetTestSuiteBuilder.using(new ReserializedSetGenerator<CLASS_TYPE>(parentBuilder.getSubjectGenerator()))
+							.named(getName() + " reserialized")
+							.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
+							.suppressing(parentBuilder.getSuppressedTests()).withSetUp(parentBuilder.getSetUp())
+							.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+		}
+		return derivedSuites;
+	}
+
+	static class ReserializedSetGenerator<E> implements TestSetGenerator<E> {
+		final OneSizeTestContainerGenerator<Collection<E>, E> gen;
+
+		private ReserializedSetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
+			this.gen = gen;
+		}
+
+		@Override
+		public SampleElements<E> samples() {
+			return gen.samples();
+		}
+
+		@Override
+		public Set<E> create(Object... elements) {
+			return (Set<E>) SerializableTester.reserialize(gen.create(elements));
+		}
+
+		@Override
+		public E[] createArray(int length) {
+			return gen.createArray(length);
+		}
+
+		@Override
+		public Iterable<E> order(List<E> insertionOrder) {
+			return gen.order(insertionOrder);
+		}
+	}
+
+	private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
+		Set<Feature<?>> derivedFeatures = new HashSet<>(features);
+#ignore
+		derivedFeatures.remove(SERIALIZABLE);
+		derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
+#endignore
+		return derivedFeatures;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/SortedSetTestSuiteBuilder.template

@@ -0,0 +1,88 @@
+package speiger.src.testers.PACKAGE.builder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.testers.SortedSetNavigationTester;
+
+import junit.framework.TestSuite;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.SUB_SORTED_SET_CLASS_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetIterationTester;
+import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPESortedSetNaviationTester;
+import speiger.src.testers.utils.SpecialFeature;
+
+@SuppressWarnings("javadoc")
+public class SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE {
+	public static GENERIC_KEY_BRACES SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE using(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return (SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE) new SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
+		testers.add(SortedSetNavigationTester.class);
+		testers.add(FILE_KEY_TYPESortedSetIterationTester.class);
+		testers.add(FILE_KEY_TYPESortedSetNaviationTester.class);
+		return testers;
+	}
+	
+	@Override
+	public TestSuite createTestSuite() {
+		if (!getFeatures().contains(CollectionFeature.KNOWN_ORDER)) {
+			List<Feature<?>> features = Helpers.copyToList(getFeatures());
+#ignore
+			features.add(CollectionFeature.KNOWN_ORDER);
+#endignore
+			withFeatures(features);
+		}
+		return super.createTestSuite();
+	}
+
+	@Override
+	protected List<TestSuite> createDerivedSuites(
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder) {
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+
+#ignore
+		if (!parentBuilder.getFeatures().contains(CollectionFeature.SUBSET_VIEW)) {
+#endignore
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubsetSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
+		}
+
+		return derivedSuites;
+	}
+
+	final TestSuite createSubsetSuite(
+			FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<CLASS_TYPE>, CLASS_TYPE>> parentBuilder,
+			Bound from, Bound to) {
+		TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+
+		List<Feature<?>> features = new ArrayList<>(parentBuilder.getFeatures());
+#ignore
+		features.remove(CollectionFeature.ALLOWS_NULL_VALUES);
+		features.add(CollectionFeature.SUBSET_VIEW);
+		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.CHILDREN_COPY);
+#endignore
+
+		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subSet " + from + "-" + to)
+				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
+				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
+	}
+
+	SORTED_SET_TEST_BUILDER KEY_GENERIC_TYPE newBuilderUsing(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+		return using(new SUB_SORTED_SET_CLASS_GENERATORBRACES(delegate, to, from));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template

@@ -0,0 +1,304 @@
+package speiger.src.testers.PACKAGE.builder.maps;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.MapTestSuiteBuilder;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.Feature;
+import com.google.common.collect.testing.features.MapFeature;
+import com.google.common.collect.testing.testers.CollectionIteratorTester;
+#if VALUE_BOOLEAN
+import com.google.common.collect.testing.testers.CollectionRemoveTester;
+import com.google.common.collect.testing.testers.CollectionRetainAllTester;
+#endif
+
+import junit.framework.TestSuite;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.testers.VALUE_PACKAGE.builder.VALUE_COLLECTION_TEST_BUILDER;
+import speiger.src.testers.VALUE_PACKAGE.generators.VALUE_TEST_COLLECTION_GENERATOR;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+#endif
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+#if TYPE_CHAR || TYPE_FLOAT || TYPE_DOUBLE
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionIteratorTester;
+#if !SAME_TYPE && !VALUE_OBJECT
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+#endif
+#else if TYPE_OBJECT && !VALUE_OBJECT
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+#endif
+#if VALUE_PRIMITIVES
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester;
+#endif
+#if VALUE_BOOLEAN
+#if !TYPE_CHAR && !TYPE_FLOAT && !TYPE_DOUBLE && !TYPE_OBJECT
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionIteratorTester;
+#endif
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRemoveAllTester;
+import speiger.src.testers.VALUE_PACKAGE.tests.collection.FILE_VALUE_TYPECollectionRetainAllTester;
+#endif
+
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester;
+import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
+import speiger.src.testers.objects.generators.TestObjectSetGenerator;
+import speiger.src.testers.objects.tests.collection.ObjectCollectionIteratorTester;
+import speiger.src.testers.objects.tests.collection.ObjectCollectionRemoveAllTester;
+import speiger.src.testers.objects.tests.collection.ObjectCollectionRetainAllTester;
+import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.testers.utils.TestUtils;
+
+@SuppressWarnings("javadoc")
+public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder<CLASS_TYPE, CLASS_VALUE_TYPE> {
+	boolean shouldBlockKeys;
+	
+	public static GENERIC_KEY_VALUE_BRACES MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+		return (MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	public MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE shouldBlockKeys(boolean value) {
+		shouldBlockKeys = value;
+		return this;
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = new ArrayList<>();
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapClearTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfAbsentTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapComputeIfPresentTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSupplyIfAbsentTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapCopyTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsKeyTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapContainsValueTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEntrySetTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapEqualsTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapForEachTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapGetOrDefaultTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapHashCodeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapIsEmptyTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapMergeBulkTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutTester.class);
+#if VALUE_PRIMITIVES
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapAddToTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSubFromTester.class);
+#endif
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutAllArrayTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapPutIfAbsentTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveEntryTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapRemoveOrDefaultTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceAllTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapReplaceEntryTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapSizeTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEMapToStringTester.class);
+		return testers;
+	}
+
+	@Override
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+		List<TestSuite> derivedSuites = new ArrayList<>();
+		derivedSuites.add(createDerivedEntrySetSuite(
+				DERIVED_MAP_GENERATORS.entrySetGenerator(parentBuilder.getSubjectGenerator()))
+						.withFeatures(computeEntrySetFeatures(parentBuilder.getFeatures()))
+						.named(parentBuilder.getName() + " entrySet")
+						.suppressing(getEntrySetSuppressing(parentBuilder.getSuppressedTests())).suppressing(getSuppressing(1))
+						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
+						.createTestSuite());
+
+		derivedSuites.add(createDerivedKeySetSuite(
+				DERIVED_MAP_GENERATORS.keySetGenerator(parentBuilder.getSubjectGenerator()))
+						.withFeatures(computeKeySetFeatures(parentBuilder.getFeatures()))
+						.named(parentBuilder.getName() + " keys").suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(0))
+						.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown())
+						.createTestSuite());
+#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
+		derivedSuites.add(createDerivedValueCollectionSuite(
+				new DERIVED_MAP_GENERATORS.MapValueCollectionGeneratorKV_BRACES(parentBuilder.getSubjectGenerator()))
+						.named(parentBuilder.getName() + " values")
+						.withFeatures(computeValuesCollectionFeatures(parentBuilder.getFeatures()))
+						.suppressing(parentBuilder.getSuppressedTests()).suppressing(getSuppressing(2)).withSetUp(parentBuilder.getSetUp())
+						.withTearDown(parentBuilder.getTearDown()).createTestSuite());
+#endif
+		return derivedSuites;
+	}
+
+	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
+		return ObjectSetTestSuiteBuilder.using(entrySetGenerator);
+	}
+	
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return SET_TEST_BUILDER.using(generator);
+	}
+	
+	protected VALUE_COLLECTION_TEST_BUILDER VALUE_GENERIC_TYPE createDerivedValueCollectionSuite(VALUE_TEST_COLLECTION_GENERATOR VALUE_GENERIC_TYPE generator) {
+		return VALUE_COLLECTION_TEST_BUILDER.using(generator);
+	}
+	
+	private Method[] getSuppressing(int type) {
+#if TYPE_CHAR || TYPE_OBJECT || TYPE_FLOAT || TYPE_DOUBLE
+		if(shouldBlockKeys) {
+			switch(type) {
+				case 0: return TestUtils.getSurpession(FILE_KEY_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+				case 1: return TestUtils.getSurpession(ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+				case 2: {
+					List<Method> result = new ArrayList<>();
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+#if VALUE_BOOLEAN
+					TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
+					TestUtils.getSurpession(result, CollectionRetainAllTester.class);
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+					TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
+#endif
+					return result.toArray(new Method[result.size()]);
+				}
+			}
+		}
+		return new Method[0];
+#else if VALUE_BOOLEAN
+		if(type == 2) {
+			List<Method> result = new ArrayList<>();
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+#if VALUE_BOOLEAN
+			TestUtils.getSurpession(result, CollectionRemoveTester.class, "testRemove_present");
+			TestUtils.getSurpession(result, CollectionRetainAllTester.class);
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+			TestUtils.getSurpession(result, FILE_VALUE_TYPECollectionRetainAllTester.class);
+#endif
+			return result.toArray(new Method[result.size()]);
+		}
+		return new Method[0];
+#else
+		return new Method[0];
+#endif
+	}
+	
+	private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {
+		Set<Feature<?>> entrySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+#ignore
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
+			entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+		}
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+			entrySetFeatures.add(SpecialFeature.COPYING);
+		}
+		else {
+			entrySetFeatures.remove(SpecialFeature.COPYING);
+		}
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
+			entrySetFeatures.add(SpecialFeature.MODIFIABLE);
+		}
+		else {
+			entrySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		}
+		entrySetFeatures.add(SpecialFeature.MAP_ENTRY);
+#endignore
+		return entrySetFeatures;
+	}
+
+	private static Set<Feature<?>> computeKeySetFeatures(Set<Feature<?>> mapFeatures) {
+		Set<Feature<?>> keySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+#ignore
+		keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+		} else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
+			keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+		}
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+			keySetFeatures.add(SpecialFeature.COPYING);
+		}
+		else {
+			keySetFeatures.remove(SpecialFeature.COPYING);
+		}
+		if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) {
+			keySetFeatures.add(SpecialFeature.MODIFIABLE);
+		}
+		else {
+			keySetFeatures.remove(SpecialFeature.MODIFIABLE);
+		}
+#endignore
+		return keySetFeatures;
+	}
+
+#if !TYPE_CHAR && !TYPE_OBJECT && !TYPE_FLOAT && !TYPE_DOUBLE || !VALUE_BOOLEAN
+	private static Set<Feature<?>> computeValuesCollectionFeatures(Set<Feature<?>> mapFeatures) {
+		Set<Feature<?>> valuesCollectionFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures);
+#ignore
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
+		}
+		if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
+			valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
+		}
+		if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) {
+			valuesCollectionFeatures.add(SpecialFeature.COPYING);
+		}
+		else {
+			valuesCollectionFeatures.remove(SpecialFeature.COPYING);
+		}
+#endignore
+		return valuesCollectionFeatures;
+	}
+	
+#endif
+	private static Set<Method> getEntrySetSuppressing(Set<Method> suppressing) {
+		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_removeAffectsBackingCollection");
+		TestUtils.getSurpession(suppressing, ObjectCollectionRemoveAllTester.class, "testRemoveAll_someFetchRemovedElements");
+		TestUtils.getSurpession(suppressing, ObjectCollectionRetainAllTester.class, "testRetainAllExtra_disjointPreviouslyNonEmpty", "testRetainAllExtra_containsDuplicatesSizeSeveral", "testRetainAllExtra_subset", "testRetainAllExtra_partialOverlap");
+#if TYPE_DOUBLE || TYPE_FLOAT
+		TestUtils.getSurpession(suppressing, CollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+		TestUtils.getSurpession(suppressing, ObjectCollectionIteratorTester.class, "testIterator_unknownOrderRemoveSupported");
+#endif
+		return suppressing;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/NavigableMapTestSuiteBuilder.template

@@ -0,0 +1,79 @@
+package speiger.src.testers.PACKAGE.builder.maps;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.features.Feature;
+
+import junit.framework.TestSuite;
+import speiger.src.testers.PACKAGE.builder.NAVIGABLE_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester;
+import speiger.src.testers.utils.SpecialFeature;
+
+@SuppressWarnings("javadoc")
+public class NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
+{
+	public static GENERIC_KEY_VALUE_BRACES NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+		return (NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE)new NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+	}
+
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPENavigableMapNavigationTester.class);
+		return testers;
+	}
+
+	@Override
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+#ignore
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.DESCENDING)) {
+			derivedSuites.add(createDescendingSuite(parentBuilder));
+		}
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
+		}
+#endignore
+		return derivedSuites;
+	}
+
+	@Override
+	NAVIGABLE_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
+		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.NavigableMapGeneratorKV_BRACES(delegate, to, from));
+	}
+
+	private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+
+		List<Feature<?>> features = new ArrayList<>();
+#ignore
+		features.add(SpecialFeature.DESCENDING);
+		features.addAll(parentBuilder.getFeatures());
+		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.CHILDREN_COPY);
+#endignore
+		return NAVIGABLE_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.DescendingTestMapGeneratorKV_BRACES(delegate))
+				.named(parentBuilder.getName() + " descending").withFeatures(features)
+				.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
+	}
+
+	@Override
+	protected NAVIGABLE_SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
+		return NAVIGABLE_SET_TEST_BUILDER.using((TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template

@@ -0,0 +1,55 @@
+package speiger.src.testers.PACKAGE.builder.maps;
+
+import java.util.List;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import junit.framework.TestSuite;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.testers.PACKAGE.builder.ORDERED_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+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.maps.TEST_ORDERED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
+#if !TYPE_OBJECT
+import speiger.src.testers.objects.builder.ObjectSetTestSuiteBuilder;
+import speiger.src.testers.objects.generators.TestObjectSetGenerator;
+import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder;
+import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
+#endif
+
+@SuppressWarnings("javadoc")
+public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
+{
+	public static GENERIC_KEY_VALUE_BRACES ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+		return (ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+	}
+	
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester.class);
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester.class);
+		return testers;
+	}
+	
+	@Override
+	public TestSuite createTestSuite() {
+#ignore
+		withFeatures(CollectionFeature.KNOWN_ORDER);
+#endignore
+		return super.createTestSuite();
+	}
+	
+	protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
+		return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator);
+	}
+	
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
+		return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/builder/maps/SortedMapTestSuiteBuilder.template

@@ -0,0 +1,90 @@
+package speiger.src.testers.PACKAGE.builder.maps;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+#endignore
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.features.Feature;
+
+import junit.framework.TestSuite;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester;
+import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.builder.SORTED_SET_TEST_BUILDER;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.utils.SpecialFeature;
+
+@SuppressWarnings("javadoc")
+public class SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE {
+	public static GENERIC_KEY_VALUE_BRACES SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE using(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator) {
+		return (SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE) new SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE().usingGenerator(generator);
+	}
+
+	@Override
+	@SuppressWarnings("rawtypes")
+	protected List<Class<? extends AbstractTester>> getTesters() {
+		List<Class<? extends AbstractTester>> testers = super.getTesters();
+		testers.add(FILE_KEY_TYPE2FILE_VALUE_TYPESortedMapNavigationTester.class);
+		return testers;
+	}
+
+	@Override
+	public TestSuite createTestSuite() {
+#ignore
+		if (!getFeatures().contains(KNOWN_ORDER)) {
+			List<Feature<?>> features = Helpers.copyToList(getFeatures());
+			features.add(KNOWN_ORDER);
+			withFeatures(features);
+		}
+#endignore
+		return super.createTestSuite();
+	}
+
+	@Override
+	protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
+		List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
+#ignore
+		if (!parentBuilder.getFeatures().contains(SpecialFeature.SUBMAP)) {
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
+			derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
+		}
+#endignore
+		return derivedSuites;
+	}
+	
+	@Override
+	protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator) {
+		return keySetGenerator instanceof TEST_SORTED_SET_GENERATOR ? SORTED_SET_TEST_BUILDER.using((TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE) keySetGenerator) : SET_TEST_BUILDER.using(keySetGenerator);
+	}
+
+	TestSuite createSubmapSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder, Bound from, Bound to) {
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
+		List<Feature<?>> features = new ArrayList<>();
+#ignore
+		features.add(SpecialFeature.SUBMAP);
+		features.addAll(parentBuilder.getFeatures());
+		features.remove(SpecialFeature.COPYING);
+		features.remove(SpecialFeature.CHILDREN_COPY);
+#endignore
+
+		return newBuilderUsing(delegate, to, from).named(parentBuilder.getName() + " subMap " + from + "-" + to)
+				.withFeatures(features).suppressing(parentBuilder.getSuppressedTests())
+				.withSetUp(parentBuilder.getSetUp()).withTearDown(parentBuilder.getTearDown()).createTestSuite();
+	}
+
+	SORTED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE newBuilderUsing(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate, Bound to, Bound from) {
+		return using(new DERIVED_MAP_GENERATORS.SortedMapGeneratorKV_BRACES(delegate, to, from));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestCollectionGenerator.template

@@ -0,0 +1,30 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import java.util.List;
+
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.TestCollectionGenerator;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+
+@SuppressWarnings("javadoc")
+public interface TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE extends TestCollectionGenerator<CLASS_TYPE>
+{
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
+#if !TYPE_OBJECT
+	public COLLECTION KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+#endif
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
+	
+	@Override
+	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
+	@Override
+	public COLLECTION KEY_GENERIC_TYPE create(Object... elements);
+	@Override
+	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
+	@Override
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestListGenerator.template

@@ -0,0 +1,16 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import com.google.common.collect.testing.TestListGenerator;
+
+import speiger.src.collections.PACKAGE.lists.LIST;
+
+@SuppressWarnings("javadoc")
+public interface TEST_LIST_GENERATOR KEY_GENERIC_TYPE extends TestListGenerator<CLASS_TYPE>, TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
+{
+	@Override
+	LIST KEY_GENERIC_TYPE create(Object... elements);
+#if !TYPE_OBJECT
+	@Override
+	LIST KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestNavigableSetGenerator.template

@@ -0,0 +1,13 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+
+@SuppressWarnings("javadoc")
+public interface TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE {
+#if !TYPE_OBJECT
+	@Override
+	NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+#endif
+	@Override
+	NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements);
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestOrderedSetGenerator.template

@@ -0,0 +1,13 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+
+@SuppressWarnings("javadoc")
+public interface TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
+#if !TYPE_OBJECT
+	@Override
+	ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+#endif
+	@Override
+	ORDERED_SET KEY_GENERIC_TYPE create(Object... elements);
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestQueueGenerator.template

@@ -0,0 +1,30 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import java.util.List;
+
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.TestContainerGenerator;
+
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+
+@SuppressWarnings("javadoc")
+public interface TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE extends TestContainerGenerator<PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE>
+{
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples();
+#if !TYPE_OBJECT
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+#endif
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder);
+	
+	@Override
+	public default SampleElements<CLASS_TYPE> samples() {return getSamples().toSamples();}
+	@Override
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements);
+	@Override
+	public default CLASS_TYPE[] createArray(int length) { return NEW_CLASS_ARRAY(length); }
+	@Override
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder);
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestSetGenerator.template

@@ -0,0 +1,15 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import com.google.common.collect.testing.TestSetGenerator;
+
+import speiger.src.collections.PACKAGE.sets.SET;
+
+@SuppressWarnings("javadoc")
+public interface TEST_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE, TestSetGenerator<CLASS_TYPE> {
+#if !TYPE_OBJECT
+	@Override
+	SET KEY_GENERIC_TYPE create(KEY_TYPE...elements);
+#endif
+	@Override
+	SET KEY_GENERIC_TYPE create(Object...elements);
+}

src/builder/resources/speiger/assets/testers/templates/generators/TestSortedSetGenerator.template

@@ -0,0 +1,38 @@
+package speiger.src.testers.PACKAGE.generators;
+
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+
+@SuppressWarnings("javadoc")
+public interface TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE extends TEST_SET_GENERATOR KEY_GENERIC_TYPE {
+#if !TYPE_OBJECT
+	@Override
+	SORTED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements);
+#endif
+	@Override
+	SORTED_SET KEY_GENERIC_TYPE create(Object... elements);
+	
+
+	  /**
+	   * Returns an element less than the {@link #samples()} and less than {@link
+	   * #belowSamplesGreater()}.
+	   */
+	  KEY_TYPE belowSamplesLesser();
+
+	  /**
+	   * Returns an element less than the {@link #samples()} but greater than {@link
+	   * #belowSamplesLesser()}.
+	   */
+	  KEY_TYPE belowSamplesGreater();
+
+	  /**
+	   * Returns an element greater than the {@link #samples()} but less than {@link
+	   * #aboveSamplesGreater()}.
+	   */
+	  KEY_TYPE aboveSamplesLesser();
+
+	  /**
+	   * Returns an element greater than the {@link #samples()} and greater than {@link
+	   * #aboveSamplesLesser()}.
+	   */
+	  KEY_TYPE aboveSamplesGreater();
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestMapGenerator.template

@@ -0,0 +1,46 @@
+package speiger.src.testers.PACKAGE.generators.maps;
+
+import java.util.Map;
+
+import com.google.common.collect.testing.Helpers;
+import com.google.common.collect.testing.SampleElements;
+import com.google.common.collect.testing.TestMapGenerator;
+
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.objects.collections.ObjectIterable;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.testers.objects.utils.ObjectSamples;
+
+@SuppressWarnings("javadoc")
+public interface TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TestMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE> {
+	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples();
+	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder);
+	public MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+	@Override
+	default MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) {
+		MAP.Entry KEY_VALUE_GENERIC_TYPE[] result = new MAP.Entry[elements.length];
+		for(int i = 0;i<elements.length;i++) {
+			result[i] = (MAP.Entry KEY_VALUE_GENERIC_TYPE) elements[i];
+		}
+		return create(result);
+	}
+	
+	@Override
+	default CLASS_TYPE[] createKeyArray(int length) { return NEW_CLASS_ARRAY(length); }
+	@Override
+	default CLASS_VALUE_TYPE[] createValueArray(int length) { return NEW_CLASS_VALUE_ARRAY(length); }
+	@Override
+	default MAP.Entry KEY_VALUE_GENERIC_TYPE[] createArray(int length) { return new MAP.Entry[length]; }
+	
+	@Override
+	default SampleElements<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> samples() {
+		ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = getSamples();
+		return new SampleElements<>(
+			Helpers.mapEntry(samples.e0().ENTRY_KEY(), samples.e0().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e1().ENTRY_KEY(), samples.e1().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e2().ENTRY_KEY(), samples.e2().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e3().ENTRY_KEY(), samples.e3().ENTRY_VALUE()), 
+			Helpers.mapEntry(samples.e4().ENTRY_KEY(), samples.e4().ENTRY_VALUE())
+		);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestOrderedMapGenerator.template

@@ -0,0 +1,13 @@
+package speiger.src.testers.PACKAGE.generators.maps;
+
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
+
+@SuppressWarnings("javadoc")
+public interface TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+{
+	@Override
+	default ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (ORDERED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
+	@Override
+	ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+}

src/builder/resources/speiger/assets/testers/templates/generators/maps/TestSortedMapGenerator.template

@@ -0,0 +1,25 @@
+package speiger.src.testers.PACKAGE.generators.maps;
+
+import com.google.common.collect.testing.TestSortedMapGenerator;
+
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
+import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+
+@SuppressWarnings("javadoc")
+public interface TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE extends TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE, TestSortedMapGenerator<CLASS_TYPE, CLASS_VALUE_TYPE>
+{
+	@Override
+	default SORTED_MAP KEY_VALUE_GENERIC_TYPE create(Object... elements) { return (SORTED_MAP KEY_VALUE_GENERIC_TYPE) TEST_MAP_GENERATOR.super.create(elements); }
+	@Override
+	SORTED_MAP KEY_VALUE_GENERIC_TYPE create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements);
+	
+	@Override
+	Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser();
+	@Override
+	Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater();
+	@Override
+	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser();
+	@Override
+	Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater();
+}

src/builder/resources/speiger/assets/testers/templates/impl/CollectionConstructorTests.template

@@ -0,0 +1,314 @@
+package speiger.src.testers.PACKAGE.impl;
+
+#if TYPE_OBJECT
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Objects;
+#endif
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
+import speiger.src.collections.PACKAGE.lists.COPY_ON_WRITE_LIST;
+import speiger.src.collections.PACKAGE.lists.IMMUTABLE_LIST;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
+import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
+import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
+import speiger.src.collections.PACKAGE.sets.IMMUTABLE_HASH_SET;
+import speiger.src.collections.PACKAGE.utils.STRATEGY;
+#endif
+#if TYPE_OBJECT
+import speiger.src.collections.objects.utils.StringSortTest;
+#endif
+import speiger.src.testers.PACKAGE.tests.collection.FILE_KEY_TYPECollectionConstructorTester;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class COLLECTION_CONSTRUCTOR_TESTS
+{
+	public static class ArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public ArrayList() {
+			setSimpleConstructor(ARRAY_LIST::new);
+			setSizeConstructor(T -> new ARRAY_LISTBRACES(T));
+			setPArrayConstructor(T -> new ARRAY_LISTBRACES(T));
+			setPCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
+			setCollectionConstructor(T -> new ARRAY_LISTBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class LinkedList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public LinkedList() {
+			setSimpleConstructor(LINKED_LIST::new);
+			setPArrayConstructor(T -> new LINKED_LISTBRACES(T));
+			setPCollectionConstructor(T -> new LINKED_LISTBRACES(T));
+			setCollectionConstructor(T -> new LINKED_LISTBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class CopyOnWriteArrayList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public CopyOnWriteArrayList() {
+			setSimpleConstructor(COPY_ON_WRITE_LIST::new);
+			setPArrayConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+			setPCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+			setCollectionConstructor(T -> new COPY_ON_WRITE_LISTBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class ImmutableList extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public ImmutableList() {
+			setPArrayConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+			setPCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+			setCollectionConstructor(T -> new IMMUTABLE_LISTBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+#if !TYPE_BOOLEAN
+	public static class HashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public HashSet() {
+			setSimpleConstructor(HASH_SET::new);
+			setSizeConstructor(T -> new HASH_SETBRACES(T));
+			setPArrayConstructor(T -> new HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new HASH_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class LinkedHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public LinkedHashSet() {
+			setSimpleConstructor(LINKED_HASH_SET::new);
+			setSizeConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setPArrayConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new LINKED_HASH_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class CustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public CustomHashSet() {
+			setSimpleConstructor(() -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPArrayConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setCollectionConstructor(T -> new CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class LinkedCustomHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public LinkedCustomHashSet() {
+			setSimpleConstructor(() -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPArrayConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setPCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+			setCollectionConstructor(T -> new LINKED_CUSTOM_HASH_SET KEY_STRING_GENERIC_TYPE(T, HashStrategy.INSTANCE));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class ImmutableHashSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public ImmutableHashSet() {
+			setPArrayConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+			setPCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+			setCollectionConstructor(T -> new IMMUTABLE_HASH_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class ArraySet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public ArraySet() {
+			setSimpleConstructor(ARRAY_SET::new);
+			setSizeConstructor(T -> new ARRAY_SETBRACES(T));
+			setPArrayConstructor(T -> new ARRAY_SETBRACES(T));
+			setPCollectionConstructor(T -> new ARRAY_SETBRACES(T));
+			setCollectionConstructor(T -> new ARRAY_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class RBTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public RBTreeSet() {
+			setSimpleConstructor(RB_TREE_SET::new);
+			setPArrayConstructor(T -> new RB_TREE_SETBRACES(T));
+			setPCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
+			setCollectionConstructor(T -> new RB_TREE_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class AVLTreeSet extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public AVLTreeSet() {
+			setSimpleConstructor(AVL_TREE_SET::new);
+			setPArrayConstructor(T -> new AVL_TREE_SETBRACES(T));
+			setPCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
+			setCollectionConstructor(T -> new AVL_TREE_SETBRACES(T));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class RBTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public RBTreeSetComparator() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> new RB_TREE_SET<String>(Comparator.naturalOrder()));
+			setPArrayConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+			setCollectionConstructor(T -> new RB_TREE_SET<>(T, Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> new RB_TREE_SET(CLASS_TYPE::compare));
+			setPArrayConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+			setPCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+			setCollectionConstructor(T -> new RB_TREE_SET(T, CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	public static class AVLTreeSetComparator extends FILE_KEY_TYPECollectionConstructorTester KEY_STRING_GENERIC_TYPE
+	{
+		@SuppressWarnings("deprecation")
+		public AVLTreeSetComparator() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> new AVL_TREE_SET<String>(Comparator.naturalOrder()));
+			setPArrayConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+			setPCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+			setCollectionConstructor(T -> new AVL_TREE_SET<>(T, Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> new AVL_TREE_SET(CLASS_TYPE::compare));
+			setPArrayConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+			setPCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+			setCollectionConstructor(T -> new AVL_TREE_SET(T, CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+#endif
+	}
+	
+	private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
+		static final HashStrategy INSTANCE = new HashStrategy();
+		@Override
+		public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
+		@Override
+		public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/impl/SimpleQueueTestGenerator.template

@@ -0,0 +1,82 @@
+package speiger.src.testers.PACKAGE.impl;
+
+import java.util.List;
+import java.util.function.Function;
+
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+#if TYPE_OBJECT
+import speiger.src.collections.objects.utils.ObjectArrays;
+#endif
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+
+@SuppressWarnings("javadoc")
+public class SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE implements TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE
+{
+	Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper;
+#if TYPE_OBJECT
+	KEY_TYPE[] keys;
+#endif
+	
+	public SIMPLE_QUEUE_TEST_GENERATOR(Function<KEY_TYPE[], PRIORITY_QUEUE KEY_GENERIC_TYPE> mapper) {
+		this.mapper = mapper;
+	}
+	
+#if TYPE_OBJECT
+	public SIMPLE_QUEUE_TEST_GENERATOR KEY_GENERIC_TYPE setElements(KEY_TYPE...keys) {
+		this.keys = keys;
+		return this;
+	}
+	
+#endif
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+#if TYPE_BOOLEAN
+		return new SAMPLE_ELEMENTS(true, false, true, false, true);
+#else if TYPE_BYTE
+		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
+#else if TYPE_SHORT
+		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
+#else if TYPE_CHAR
+		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
+#else if TYPE_OBJECT
+		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
+#else
+		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
+#endif
+	}
+	
+#if !TYPE_OBJECT
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+		return mapper.apply(elements);
+	}
+	
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		int i = 0;
+		for (Object e : elements) {
+			array[i++] = CLASS_TO_KEY(e);
+		}
+		return mapper.apply(array);
+	}
+	
+#else
+	public PRIORITY_QUEUE KEY_GENERIC_TYPE create(Object... elements) {
+		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
+		int i = 0;
+		for (Object e : elements) {
+			array[i++] = CLASS_TO_KEY(e);
+		}
+		return mapper.apply(array);
+	}
+
+#endif
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		return insertionOrder;
+	}
+	
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		return insertionOrder;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/impl/SimpleTestGenerator.template

@@ -0,0 +1,221 @@
+package speiger.src.testers.PACKAGE.impl;
+
+import java.util.List;
+import java.util.function.Function;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.LIST;
+#if !TYPE_BOOLEAN
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+#if TYPE_OBJECT
+import speiger.src.collections.objects.utils.ObjectArrays;
+#endif
+#endif
+import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_LIST_GENERATOR;
+#if !TYPE_BOOLEAN
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+#endif
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+
+@SuppressWarnings("javadoc")
+public class SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E extends COLLECTION KEY_GENERIC_TYPE> {
+	Function<KEY_TYPE[], E> mapper;
+#if TYPE_OBJECT
+	KEY_TYPE[] keys;
+#endif
+	
+	public SIMPLE_TEST_GENERATOR(Function<KEY_TYPE[], E> mapper) {
+		this.mapper = mapper;
+	}
+	
+#if TYPE_OBJECT
+	public SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<E> setElements(KEY_TYPE...keys) {
+		this.keys = keys;
+		return this;
+	}
+	
+#endif
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+#if TYPE_BOOLEAN
+		return new SAMPLE_ELEMENTS(true, false, true, false, true);
+#else if TYPE_BYTE
+		return new SAMPLE_ELEMENTS((byte)0, (byte)1, (byte)2, (byte)3, (byte)4);
+#else if TYPE_SHORT
+		return new SAMPLE_ELEMENTS((short)0, (short)1, (short)2, (short)3, (short)4);
+#else if TYPE_CHAR
+		return new SAMPLE_ELEMENTS((char)0, (char)1, (char)2, (char)3, (char)4);
+#else if TYPE_OBJECT
+		return new SAMPLE_ELEMENTSBRACES(keys[0], keys[1], keys[2], keys[3], keys[4]);
+#else
+		return new SAMPLE_ELEMENTS(0, 1, 2, 3, 4);
+#endif
+	}
+	
+#if !TYPE_OBJECT
+	public E create(KEY_TYPE... elements) {
+		return mapper.apply(elements);
+	}
+	
+	public E create(Object... elements) {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		int i = 0;
+		for (Object e : elements) {
+			array[i++] = CLASS_TO_KEY(e);
+		}
+		return mapper.apply(array);
+	}
+	
+#else
+	public E create(Object... elements) {
+		T[] array = (T[])ObjectArrays.newArray(keys[0].getClass(), elements.length);
+		int i = 0;
+		for (Object e : elements) {
+			array[i++] = CLASS_TO_KEY(e);
+		}
+		return mapper.apply(array);
+	}
+
+#endif
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		return insertionOrder;
+	}
+	
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		return insertionOrder;
+	}
+	
+	public static class Collections KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<COLLECTION KEY_GENERIC_TYPE> implements TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE
+	{
+		public Collections(Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+	public static class Lists KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<LIST KEY_GENERIC_TYPE> implements TEST_LIST_GENERATOR KEY_GENERIC_TYPE
+	{
+		public Lists(Function<KEY_TYPE[], LIST KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+#if !TYPE_BOOLEAN
+	public static class Sets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SET KEY_GENERIC_TYPE> implements TEST_SET_GENERATOR KEY_GENERIC_TYPE
+	{
+		public Sets(Function<KEY_TYPE[], SET KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+	public static class OrderedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<ORDERED_SET KEY_GENERIC_TYPE> implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE
+	{
+		public OrderedSets(Function<KEY_TYPE[], ORDERED_SET KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+	public static class SortedSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<SORTED_SET KEY_GENERIC_TYPE> implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
+	{
+		public SortedSets(Function<KEY_TYPE[], SORTED_SET KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+		
+		@Override
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+			insertionOrder.sort(null);
+			return insertionOrder;
+		}
+		
+		@Override
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+			insertionOrder.sort(null);
+			return insertionOrder;
+		}
+		
+#if TYPE_CHAR
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return '_'; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return '`'; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
+#else if TYPE_OBJECT
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
+#else
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return -2; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return -1; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return 5; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return 6; }
+#endif
+	}
+	
+	public static class NavigableSets KEY_GENERIC_TYPE extends SIMPLE_TEST_GENERATOR KKS_GENERIC_TYPE<NAVIGABLE_SET KEY_GENERIC_TYPE> implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE
+	{
+		public NavigableSets(Function<KEY_TYPE[], NAVIGABLE_SET KEY_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+		
+		@Override
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+			insertionOrder.sort(null);
+			return insertionOrder;
+		}
+		
+		@Override
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+			insertionOrder.sort(null);
+			return insertionOrder;
+		}
+		
+#if TYPE_CHAR
+		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() { return new SAMPLE_ELEMENTS('a', 'b', 'c', 'd', 'e'); }
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return '_'; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return '`'; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return 'f'; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return 'g'; }
+#else if TYPE_OBJECT
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return keys[5]; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return keys[6]; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return keys[7]; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return keys[8]; }
+#else
+		@Override
+		public KEY_TYPE belowSamplesLesser() { return -2; }
+		@Override
+		public KEY_TYPE belowSamplesGreater() { return -1; }
+		@Override
+		public KEY_TYPE aboveSamplesLesser() { return 5; }
+		@Override
+		public KEY_TYPE aboveSamplesGreater() { return 6; }
+#endif
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/impl/SortedSetSubsetTestSetGenerator.template

@@ -0,0 +1,173 @@
+package speiger.src.testers.PACKAGE.impl;
+
+#if TYPE_OBJECT
+import java.util.Comparator;
+#endif
+import java.util.List;
+
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+#endif
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+
+@SuppressWarnings("javadoc")
+public class SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE
+{
+	final Bound to;
+	final Bound from;
+	final KEY_TYPE firstInclusive;
+	final KEY_TYPE lastInclusive;
+	private final COMPARATOR KEY_GENERIC_TYPE comparator;
+	private final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate;
+
+	public SUB_SORTED_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+		this.to = to;
+		this.from = from;
+		this.delegate = delegate;
+
+		SORTED_SET KEY_GENERIC_TYPE emptySet = delegate.create(NEW_KEY_ARRAY(0));
+		comparator = emptySet.comparator();
+
+		SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples = delegate.getSamples();
+		LIST KEY_GENERIC_TYPE samplesList = new ARRAY_LISTBRACES(samples.asList());
+		samplesList.sort(comparator);
+		firstInclusive = samplesList.GET_KEY(0);
+		lastInclusive = samplesList.GET_KEY(samplesList.size() - 1);
+	}
+
+	public final TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE getInnerGenerator() {
+		return delegate;
+	}
+
+	public final Bound getTo() {
+		return to;
+	}
+
+	public final Bound getFrom() {
+		return from;
+	}
+
+	SORTED_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE set, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+		if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
+			return set.headSet(lastExclusive);
+		} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
+			return set.tailSet(firstInclusive);
+		} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
+			return set.subSet(firstInclusive, lastExclusive);
+		} else {
+			throw new IllegalArgumentException();
+		}
+	}
+
+	@Override
+	public KEY_TYPE belowSamplesLesser() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public KEY_TYPE belowSamplesGreater() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public KEY_TYPE aboveSamplesLesser() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public KEY_TYPE aboveSamplesGreater() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+		return delegate.getSamples();
+	}
+
+	@Override
+	public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+		return delegate.order(insertionOrder);
+	}
+
+	@Override
+	public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+		return delegate.order(insertionOrder);
+	}
+
+	@Override
+	public SORTED_SET KEY_GENERIC_TYPE create(KEY_OBJECT_TYPE... elements) {
+#if TYPE_OBJECT
+		LIST KEY_GENERIC_TYPE normalValues = (LIST KEY_GENERIC_TYPE)ARRAY_LIST.wrap(elements);
+#else
+		LIST KEY_GENERIC_TYPE normalValues = ARRAY_LIST.wrap(elements);
+#endif
+		LIST KEY_GENERIC_TYPE extremeValues = new ARRAY_LISTBRACES();
+		KEY_TYPE firstExclusive = delegate.belowSamplesGreater();
+		KEY_TYPE lastExclusive = delegate.aboveSamplesLesser();
+		if (from != Bound.NO_BOUND) {
+			extremeValues.add(delegate.belowSamplesLesser());
+			extremeValues.add(delegate.belowSamplesGreater());
+		}
+		if (to != Bound.NO_BOUND) {
+			extremeValues.add(delegate.aboveSamplesLesser());
+			extremeValues.add(delegate.aboveSamplesGreater());
+		}
+		LIST KEY_GENERIC_TYPE allEntries = new ARRAY_LISTBRACES();
+		allEntries.addAll(extremeValues);
+		allEntries.addAll(normalValues);
+		SORTED_SET KEY_GENERIC_TYPE set = delegate.create(allEntries.toArray());
+
+		return createSubSet(set, firstExclusive, lastExclusive);
+	}
+	
+#if !TYPE_OBJECT
+	@Override
+	public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(elements.length);
+		int i = 0;
+		for (Object e : elements) {
+			array[i++] = CLASS_TO_KEY(e);
+		}
+		return create(array);
+	}
+
+#endif
+	public static final class SUB_NAVIGABLE_SET_CLASS_GENERATOR KEY_GENERIC_TYPE extends SUB_SORTED_SET_CLASS_GENERATOR KEY_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
+		public SUB_NAVIGABLE_SET_CLASS_GENERATOR(TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE delegate, Bound to, Bound from) {
+			super(delegate, to, from);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
+		}
+		
+#endif
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.create(elements);
+		}
+		
+		@Override
+		NAVIGABLE_SET KEY_GENERIC_TYPE createSubSet(SORTED_SET KEY_GENERIC_TYPE sortedSet, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+			NAVIGABLE_SET KEY_GENERIC_TYPE set = (NAVIGABLE_SET KEY_GENERIC_TYPE) sortedSet;
+			if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) return set.headSet(lastInclusive, true);	
+			else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) return set.tailSet(firstExclusive, false);	
+			else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) return set.subSet(firstExclusive, false, lastExclusive, false);
+			else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstExclusive, false, lastInclusive, true);
+			else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) return set.subSet(firstInclusive, true, lastInclusive, true);
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE)super.createSubSet(set, firstExclusive, lastExclusive);
+
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template

@@ -0,0 +1,550 @@
+package speiger.src.testers.PACKAGE.impl.maps;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+#if VALUE_OBJECT
+import java.util.Objects;
+#endif
+
+import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.functions.COMPARATOR;
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+#endif
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
+import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
+#endif
+import speiger.src.collections.PACKAGE.sets.SORTED_SET;
+import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
+#endif
+import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_SORTED_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.TEST_NAVIGABLE_SET_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+#endif
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
+#if !VALUE_OBJECT && !SAME_TYPE
+import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERABLE;
+import speiger.src.collections.VALUE_PACKAGE.lists.VALUE_LIST;
+import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_COMPARATOR;
+#endif
+import speiger.src.testers.VALUE_PACKAGE.generators.VALUE_TEST_COLLECTION_GENERATOR;
+#if !VALUE_OBJECT && !SAME_TYPE
+import speiger.src.testers.VALUE_PACKAGE.utils.VALUE_SAMPLE_ELEMENTS;
+#endif
+import speiger.src.collections.objects.collections.ObjectIterable;
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.sets.ObjectSet;
+import speiger.src.collections.objects.sets.ObjectOrderedSet;
+import speiger.src.collections.objects.utils.ObjectIterators;
+import speiger.src.collections.objects.utils.ObjectLists;
+import speiger.src.testers.objects.generators.TestObjectSetGenerator;
+#if !TYPE_OBJECT
+import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
+#endif
+import speiger.src.testers.objects.utils.ObjectSamples;
+
+@SuppressWarnings("javadoc")
+public class DERIVED_MAP_GENERATORS {
+	public static class NavigableMapGenerator KEY_VALUE_GENERIC_TYPE extends SortedMapGenerator KEY_VALUE_GENERIC_TYPE {
+		public NavigableMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent, Bound to, Bound from) {
+			super(parent, to, from);
+		}
+		
+	    @Override
+	    NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE createSubMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE sortedMap, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+	    	NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE map = (NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE) sortedMap;
+	      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
+	        return map.headMap(lastInclusive, true);
+	      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
+	        return map.tailMap(firstExclusive, false);
+	      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
+	        return map.subMap(firstExclusive, false, lastExclusive, false);
+	      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
+	        return map.subMap(firstExclusive, false, lastInclusive, true);
+	      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
+	        return map.subMap(firstInclusive, true, lastInclusive, true);
+	      } else {
+	        return (NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE) super.createSubMap(map, firstExclusive, lastExclusive);
+	      }
+	    }
+	}
+	
+	public static class SortedMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE {
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
+		Bound to;
+		Bound from;
+		KEY_TYPE firstInclusive;
+		KEY_TYPE lastInclusive;
+		Comparator<Entry KEY_VALUE_GENERIC_TYPE> entryComparator;
+
+		public SortedMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent, Bound to, Bound from) {
+			super(parent);
+			this.parent = parent;
+			this.to = to;
+			this.from = from;
+			SORTED_MAP KEY_VALUE_GENERIC_TYPE map = parent.create();
+			entryComparator = DERIVED_MAP_GENERATORS.entryComparator(map.comparator());
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> samples = parent.getSamples().asList();
+			samples.sort(entryComparator);
+			firstInclusive = samples.get(0).ENTRY_KEY();
+			lastInclusive = samples.get(samples.size() - 1).ENTRY_KEY();
+		}
+		
+		@Override
+		public SORTED_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
+			if (from != Bound.NO_BOUND) {
+				entries.add(parent.belowSamplesLesser());
+				entries.add(parent.belowSamplesGreater());
+			}
+			if (to != Bound.NO_BOUND) {
+				entries.add(parent.aboveSamplesLesser());
+				entries.add(parent.aboveSamplesGreater());
+			}
+			entries.addAll(elements);
+			return createSubMap(parent.create(entries.toArray(Entry[]::new)), parent.belowSamplesGreater().ENTRY_KEY(), parent.aboveSamplesLesser().ENTRY_KEY());
+		}
+		
+		SORTED_MAP KEY_VALUE_GENERIC_TYPE createSubMap(SORTED_MAP KEY_VALUE_GENERIC_TYPE map, KEY_TYPE firstExclusive, KEY_TYPE lastExclusive) {
+			if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
+				return map.headMap(lastExclusive);
+			} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
+				return map.tailMap(firstInclusive);
+			} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
+				return map.subMap(firstInclusive, lastExclusive);
+			} else {
+				throw new IllegalArgumentException();
+			}
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() {
+			throw new UnsupportedOperationException();
+		}
+	}
+	
+	public static class DescendingTestMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
+		
+		public DescendingTestMapGenerator(TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
+			super(parent);
+			this.parent = parent;
+		}
+
+		@Override
+		public NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
+			return ((NAVIGABLE_MAP KEY_VALUE_GENERIC_TYPE)parent.create(elements)).descendingMap();
+		}
+		
+		@Override
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+			ObjectList<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> values = ObjectIterators.pour(ObjectIterators.wrap(parent.order(insertionOrder).iterator()));
+			ObjectLists.reverse(values);
+			return values;
+		}
+		
+		@Override
+		public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> values = parent.order(insertionOrder).pourAsList();
+			ObjectLists.reverse(values);
+			return values;
+		}
+		
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() {
+			return parent.aboveSamplesGreater();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() {
+			return parent.aboveSamplesLesser();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() {
+			return parent.belowSamplesGreater();
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() {
+			return parent.belowSamplesLesser();
+		}
+	}
+	
+	public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
+		
+		public MapGenerator(TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
+			this.parent = parent;
+		}
+
+		@Override
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+			return parent.order(insertionOrder);
+		}
+		
+		@Override
+		public ObjectSamples<Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
+			return parent.getSamples();
+		}
+		
+		@Override
+		public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+			return parent.order(insertionOrder);
+		}
+		
+		@Override
+		public MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
+			return parent.create(elements);
+		}
+	}
+	
+	public static GENERIC_KEY_VALUE_BRACES TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+		if(inner.getInnerGenerator() instanceof TEST_ORDERED_MAP_GENERATOR) {
+			ObjectSet<Entry KEY_VALUE_GENERIC_TYPE> set = ((TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().ENTRY_SET();
+			if(set instanceof ObjectOrderedSet) return new OrderedMapEntrySetGeneratorKV_BRACES(inner);
+		}
+		return new MapEntrySetGeneratorKV_BRACES(inner);
+	}
+	
+	public static class OrderedMapEntrySetGenerator KEY_VALUE_GENERIC_TYPE extends MapEntrySetGenerator KEY_VALUE_GENERIC_TYPE implements TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
+		
+		public OrderedMapEntrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			super(inner);
+		}
+		
+		public ObjectOrderedSet<Entry KEY_VALUE_GENERIC_TYPE> create(Object... elements) {
+			return (ObjectOrderedSet<Entry KEY_VALUE_GENERIC_TYPE>)super.create(elements);
+		}
+	}
+	
+	public static class MapEntrySetGenerator KEY_VALUE_GENERIC_TYPE implements TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
+		TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
+
+		public MapEntrySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
+		}
+
+		@Override
+		public ObjectSamples<Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
+			return generator.getSamples();
+		}
+
+		@Override
+		public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+			return generator.order(insertionOrder);
+		}
+
+		@Override
+		public Iterable<Entry KEY_VALUE_GENERIC_TYPE> order(List<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+			return generator.order(new ObjectArrayList<Entry KEY_VALUE_GENERIC_TYPE>(insertionOrder));
+		}
+
+		@Override
+		public Entry KEY_VALUE_GENERIC_TYPE[] createArray(int length) {
+			return new Entry[length];
+		}
+
+		@Override
+		public ObjectSet<Entry KEY_VALUE_GENERIC_TYPE> create(Object... elements) {
+			return generator.create(elements).ENTRY_SET();
+		}
+	}
+
+	public static GENERIC_KEY_VALUE_BRACES TEST_SET_GENERATOR KEY_GENERIC_TYPE keySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+		if (inner.getInnerGenerator() instanceof TEST_SORTED_MAP_GENERATOR) {
+			SET KEY_GENERIC_TYPE set = ((TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().keySet();
+			if(set instanceof NAVIGABLE_SET) return new MapNavigableKeySetGeneratorKV_BRACES(inner);
+			if(set instanceof SORTED_SET) return new MapSortedKeySetGeneratorKV_BRACES(inner);
+		}
+		if(inner.getInnerGenerator() instanceof TEST_ORDERED_MAP_GENERATOR) {
+			SET KEY_GENERIC_TYPE set = ((TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator()).create().keySet();
+			if(set instanceof ORDERED_SET) return new MapOrderedKeySetGeneratorKV_BRACES(inner);
+		}
+		return new MapKeySetGeneratorKV_BRACES(inner);
+	}
+	
+	public static class MapNavigableKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapSortedKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_NAVIGABLE_SET_GENERATOR KEY_GENERIC_TYPE {
+		public MapNavigableKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			super(inner);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+
+#endif
+		@Override
+		public NAVIGABLE_SET KEY_GENERIC_TYPE create(Object... elements) {
+			return (NAVIGABLE_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+	}
+	
+	public static class MapSortedKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SORTED_SET_GENERATOR KEY_GENERIC_TYPE {
+		TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
+
+		public MapSortedKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			super(inner);
+			generator = (TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
+		}
+
+#if !TYPE_OBJECT
+		@Override
+		public SORTED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			return (SORTED_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+
+#endif
+		@Override
+		public SORTED_SET KEY_GENERIC_TYPE create(Object... elements) {
+			return (SORTED_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+
+		@Override
+		public KEY_TYPE belowSamplesLesser() {
+			return generator.belowSamplesLesser().ENTRY_KEY();
+		}
+
+		@Override
+		public KEY_TYPE belowSamplesGreater() {
+			return generator.belowSamplesGreater().ENTRY_KEY();
+		}
+
+		@Override
+		public KEY_TYPE aboveSamplesLesser() {
+			return generator.aboveSamplesLesser().ENTRY_KEY();
+		}
+
+		@Override
+		public KEY_TYPE aboveSamplesGreater() {
+			return generator.aboveSamplesGreater().ENTRY_KEY();
+		}
+	}
+	
+	public static class MapOrderedKeySetGenerator KEY_VALUE_GENERIC_TYPE extends MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE {
+		
+		public MapOrderedKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			super(inner);
+		}
+
+#if !TYPE_OBJECT
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			return (ORDERED_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+
+#endif
+		@Override
+		public ORDERED_SET KEY_GENERIC_TYPE create(Object... elements) {
+			return (ORDERED_SET KEY_GENERIC_TYPE) super.create(elements);
+		}
+	}
+	
+	public static class MapKeySetGenerator KEY_VALUE_GENERIC_TYPE implements TEST_SET_GENERATOR KEY_GENERIC_TYPE {
+		TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
+		SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples;
+
+		public MapKeySetGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
+			ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = generator.getSamples();
+			this.samples = new SAMPLE_ELEMENTSBRACES(samples.e0().ENTRY_KEY(), samples.e1().ENTRY_KEY(), samples.e2().ENTRY_KEY(), samples.e3().ENTRY_KEY(), samples.e4().ENTRY_KEY());
+		}
+
+		@Override
+		public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() {
+			return samples;
+		}
+
+		@Override
+		public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) {
+			VALUE_TYPE value = generator.getSamples().e0().ENTRY_VALUE();
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
+			for (KEY_TYPE key : insertionOrder) {
+				entries.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(key, value));
+			}
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.order(entries)) {
+				list.add(entry.ENTRY_KEY());
+			}
+			return list;
+		}
+
+		@Override
+		public Iterable<CLASS_TYPE> order(List<CLASS_TYPE> insertionOrder) {
+			VALUE_TYPE value = generator.getSamples().e0().ENTRY_VALUE();
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> entries = new ObjectArrayList<>();
+			for (KEY_TYPE key : insertionOrder) {
+				entries.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(key, value));
+			}
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.order(entries)) {
+				list.add(entry.ENTRY_KEY());
+			}
+			return list;
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) {
+			Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
+			int index = 0;
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
+				result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(elements[index++], entry.ENTRY_VALUE());
+			}
+			return generator.create(result).keySet();
+		}
+
+#endif
+		@Override
+		public SET KEY_GENERIC_TYPE create(Object... elements) {
+			Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
+			int index = 0;
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
+				result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES((CLASS_TYPE) elements[index++], entry.getValue());
+			}
+			return generator.create(result).keySet();
+		}
+	}
+
+	public static class MapValueCollectionGenerator KEY_VALUE_GENERIC_TYPE implements VALUE_TEST_COLLECTION_GENERATOR VALUE_GENERIC_TYPE {
+		TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE generator;
+		VALUE_SAMPLE_ELEMENTS VALUE_GENERIC_TYPE samples;
+
+		public MapValueCollectionGenerator(OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> inner) {
+			generator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) inner.getInnerGenerator();
+			ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> samples = generator.getSamples();
+			this.samples = new VALUE_SAMPLE_ELEMENTSVALUE_BRACES(samples.e0().ENTRY_VALUE(), samples.e1().ENTRY_VALUE(), samples.e2().ENTRY_VALUE(), samples.e3().ENTRY_VALUE(), samples.e4().ENTRY_VALUE());
+		}
+		
+		@Override
+		public VALUE_SAMPLE_ELEMENTS VALUE_GENERIC_TYPE getSamples() {
+			return samples;
+		}
+
+		@Override
+		public VALUE_ITERABLE VALUE_GENERIC_TYPE order(VALUE_LIST VALUE_GENERIC_TYPE insertionOrder) {
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> list = generator.order(generator.getSamples().asList()).pourAsList();
+#if VALUE_OBJECT
+			insertionOrder.sort(new Comparator<VALUE_TYPE>() {
+#else
+			insertionOrder.sort(new VALUE_COMPARATOR VALUE_GENERIC_TYPE() {
+#endif
+				@Override
+				public int compare(VALUE_TYPE key, VALUE_TYPE value) {
+					return Integer.signum(indexOf(key) - indexOf(value));
+				}
+				
+				protected int indexOf(VALUE_TYPE entry) {
+					for(int i = 0,m=list.size();i<m;i++) {
+						if(VALUE_EQUALS(list.get(i).ENTRY_VALUE(), entry)) return i;
+					}
+					throw new IllegalArgumentException("MAP.values generator can order only sample values");
+				}
+			});
+			return insertionOrder;
+		}
+
+		@Override
+		public Iterable<CLASS_VALUE_TYPE> order(List<CLASS_VALUE_TYPE> insertionOrder) {
+			ObjectList<Entry KEY_VALUE_GENERIC_TYPE> list = generator.order(generator.getSamples().asList()).pourAsList();
+			insertionOrder.sort(new Comparator<CLASS_VALUE_TYPE>() {
+				@Override
+				public int compare(CLASS_VALUE_TYPE key, CLASS_VALUE_TYPE value) {
+					return Integer.signum(indexOf(key) - indexOf(value));
+				}
+				
+				protected int indexOf(CLASS_VALUE_TYPE entry) {
+					for(int i = 0,m=list.size();i<m;i++) {
+						if(VALUE_EQUALS(list.get(i).ENTRY_VALUE(), OBJ_TO_VALUE(entry))) return i;
+					}
+					throw new IllegalArgumentException("MAP.values generator can order only sample values");
+				}
+			});
+			return insertionOrder;
+		}
+		
+#if !VALUE_OBJECT
+		@Override
+		public VALUE_COLLECTION VALUE_GENERIC_TYPE create(VALUE_TYPE... elements) {
+			Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
+			int index = 0;
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
+				result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.ENTRY_KEY(), elements[index++]);
+			}
+			return generator.create(result).values();
+		}
+		
+#endif
+		@Override
+		public VALUE_COLLECTION VALUE_GENERIC_TYPE create(Object... elements) {
+			Entry KEY_VALUE_GENERIC_TYPE[] result = new Entry[elements.length];
+			int index = 0;
+			for (Entry KEY_VALUE_GENERIC_TYPE entry : generator.getSamples().asList().subList(0, elements.length)) {
+				result[index] = new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), (CLASS_VALUE_TYPE)elements[index++]);
+			}
+			return generator.create(result).values();
+		}
+	}
+	
+	public static KEY_VALUE_GENERIC_TYPE Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> entryObjectComparator(Comparator<CLASS_TYPE> keyComparator) {
+		return new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
+			@Override
+			public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> a, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> b) {
+				if(keyComparator == null) {
+					return COMPAREABLE_TO_KEY(OBJ_TO_KEY(a.getKey()), OBJ_TO_KEY(b.getKey()));
+				}
+				return keyComparator.compare(OBJ_TO_KEY(a.getKey()), OBJ_TO_KEY(b.getKey()));
+			}
+		};
+	}
+	
+	public static KEY_VALUE_GENERIC_TYPE Comparator<Entry KEY_VALUE_GENERIC_TYPE> entryComparator(COMPARATOR KEY_GENERIC_TYPE keyComparator) {
+		return new Comparator<Entry KEY_VALUE_GENERIC_TYPE>() {
+			@Override
+			public int compare(Entry KEY_VALUE_GENERIC_TYPE a, Entry KEY_VALUE_GENERIC_TYPE b) {
+				if(keyComparator == null) {
+					return COMPAREABLE_TO_KEY(a.ENTRY_KEY(), b.ENTRY_KEY());
+				}
+				return keyComparator.compare(a.ENTRY_KEY(), b.ENTRY_KEY());
+			}
+		};
+	}
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/MapConstructorTests.template

@@ -0,0 +1,934 @@
+package speiger.src.testers.PACKAGE.impl.maps;
+
+#if TYPE_OBJECT || VALUE_OBJECT
+import java.util.Arrays;
+#endif
+#if TYPE_OBJECT
+import java.util.Objects;
+import java.util.Comparator;
+#endif
+
+#if TYPE_OBJECT
+import org.junit.Assert;
+#endif
+import org.junit.Ignore;
+import org.junit.Test;
+
+#if TYPE_OBJECT
+import com.google.common.collect.testing.AnEnum;
+#endif
+
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.impl.hash.HASH_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.hash.LINKED_HASH_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.customHash.CUSTOM_HASH_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.customHash.LINKED_CUSTOM_HASH_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.concurrent.CONCURRENT_HASH_MAP;
+#if TYPE_OBJECT
+import speiger.src.collections.PACKAGE.maps.impl.misc.ENUM_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.misc.LINKED_ENUM_MAP;
+#endif
+
+import speiger.src.collections.PACKAGE.maps.impl.tree.RB_TREE_MAP;
+import speiger.src.collections.PACKAGE.maps.impl.tree.AVL_TREE_MAP;
+import speiger.src.collections.PACKAGE.utils.STRATEGY;
+import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester;
+#if TYPE_OBJECT || VALUE_OBJECT
+import speiger.src.collections.objects.utils.StringSortTest;
+#endif
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class MAP_CONSTRUCTOR_TESTS
+{
+	public static class HashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public HashMap() {
+			setSimpleConstructor(MAP.builder()::map);
+			setSizeConstructor(MAP.builder()::map);
+			setPArrayConstructor(MAP.builder()::map);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(MAP.builder()::map);
+#endif
+			setPMapConstructor(MAP.builder()::map);
+			setMapConstructor(MAP.builder()::map);
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class LinkedHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public LinkedHashMap() {
+			setSimpleConstructor(MAP.builder()::linkedMap);
+			setSizeConstructor(MAP.builder()::linkedMap);
+			setPArrayConstructor(MAP.builder()::linkedMap);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(MAP.builder()::linkedMap);
+#endif
+			setPMapConstructor(MAP.builder()::linkedMap);
+			setMapConstructor(MAP.builder()::linkedMap);
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new LINKED_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new LINKED_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+#if TYPE_OBJECT
+#if VALUE_OBJECT
+	public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
+#else
+	public static class EnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum>
+#endif
+	{
+		public EnumMap() {
+			setSimpleConstructor(() -> new ENUM_MAP<>(AnEnum.class));
+			setPArrayConstructor(ENUM_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(ENUM_MAP::new);
+#endif
+			setPMapConstructor(ENUM_MAP::new);
+			setMapConstructor(ENUM_MAP::new);
+		}
+		
+		@Test
+		public void testEnumMapConstructor() {
+			if(pMapConstructor == null) return;
+			Assert.assertTrue(pMapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+		}
+		
+		@Test
+		public void testObjectEnumMapConstructor() {
+			if(pMapConstructor == null) return;
+			Assert.assertTrue(mapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+		}
+		
+		@Override
+		protected AnEnum[] createKeyElements() {
+			return AnEnum.values();
+		}
+		
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOf(StringSortTest.NAMES, AnEnum.values().length);
+		}
+#else
+		@Override
+		protected int getSize() {
+			return AnEnum.values().length;
+		}
+#endif
+	}
+
+#if VALUE_OBJECT
+	public static class LinkedEnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum, String>
+#else
+	public static class LinkedEnumMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester<AnEnum>
+#endif
+	{
+		public LinkedEnumMap() {
+			setSimpleConstructor(() -> new LINKED_ENUM_MAP<>(AnEnum.class));
+			setPArrayConstructor(LINKED_ENUM_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(LINKED_ENUM_MAP::new);
+#endif
+			setPMapConstructor(LINKED_ENUM_MAP::new);
+			setMapConstructor(LINKED_ENUM_MAP::new);
+		}
+		
+		@Test
+		public void testEnumMapConstructor() {
+			if(pMapConstructor == null) return;
+			Assert.assertTrue(pMapConstructor.apply(new LINKED_ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+			Assert.assertTrue(pMapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+		}
+		
+		@Test
+		public void testObjectEnumMapConstructor() {
+			if(mapConstructor == null) return;
+			Assert.assertTrue(mapConstructor.apply(new LINKED_ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+			Assert.assertTrue(mapConstructor.apply(new ENUM_MAP<>(new LINKED_HASH_MAPKV_BRACES(keys, values))) != null);
+		}
+		
+		@Override
+		protected AnEnum[] createKeyElements() {
+			return AnEnum.values();
+		}
+		
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOf(StringSortTest.NAMES, AnEnum.values().length);
+		}
+#else
+		@Override
+		protected int getSize() {
+			return AnEnum.values().length;
+		}
+#endif
+	}
+	
+#endif
+	public static class CustomHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public CustomHashMap() {
+			setSimpleConstructor(() -> MAP.builder().customMap(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
+			setPArrayConstructor((K, V) -> MAP.builder().customMap(K, V, HashStrategy.INSTANCE));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().customMap(K, V, HashStrategy.INSTANCE));
+#endif
+			setPMapConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
+			setMapConstructor(T -> MAP.builder().customMap(T, HashStrategy.INSTANCE));
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F, HashStrategy.INSTANCE));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F, HashStrategy.INSTANCE));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class LinkedCustomHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public LinkedCustomHashMap() {
+			setSimpleConstructor(() -> MAP.builder().customLinkedMap(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
+			setPArrayConstructor((K, V) -> MAP.builder().customLinkedMap(K, V, HashStrategy.INSTANCE));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().customLinkedMap(K, V, HashStrategy.INSTANCE));
+#endif
+			setPMapConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
+			setMapConstructor(T -> MAP.builder().customLinkedMap(T, HashStrategy.INSTANCE));
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new LINKED_CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F, HashStrategy.INSTANCE));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new LINKED_CUSTOM_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F, HashStrategy.INSTANCE));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ImmutableHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ImmutableHashMap() {
+			setPArrayConstructor(MAP.builder()::immutable);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(MAP.builder()::immutable);
+#endif
+			setPMapConstructor(MAP.builder()::immutable);
+			setMapConstructor(MAP.builder()::immutable);
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ConcurrentHashMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ConcurrentHashMap() {
+			setSimpleConstructor(CONCURRENT_HASH_MAP::new);
+			setSizeConstructor(CONCURRENT_HASH_MAP::new);
+			setPArrayConstructor(CONCURRENT_HASH_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(CONCURRENT_HASH_MAP::new);
+#endif
+			setPMapConstructor(CONCURRENT_HASH_MAP::new);
+			setMapConstructor(CONCURRENT_HASH_MAP::new);
+		}
+		
+		@Test
+		public void testWrongLoadFactorSize() {
+			setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 1F));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 1 LoadFactor should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+		@Test
+		public void testWrongConcurrency() {
+			setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, 0));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 0 Concurrency should error");
+			} catch(IllegalStateException e) {
+			}
+			
+			setSizeConstructor(T -> new CONCURRENT_HASH_MAP KEY_VALUE_STRING_GENERIC_TYPE(T, Integer.MAX_VALUE));
+			try {
+				testSizeConstructor_smallSize();
+				fail("A Constructor using a 65536 or larger Concurrency should error");
+			} catch(IllegalStateException e) {
+			}
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ArrayMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ArrayMap() {
+			setSimpleConstructor(MAP.builder()::arrayMap);
+			setSizeConstructor(MAP.builder()::arrayMap);
+			setPArrayConstructor(MAP.builder()::arrayMap);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(MAP.builder()::arrayMap);
+#endif
+			setPMapConstructor(MAP.builder()::arrayMap);
+			setMapConstructor(MAP.builder()::arrayMap);
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class RBTreeMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public RBTreeMap() {
+			setSimpleConstructor(MAP.builder()::rbTreeMap);
+			setPArrayConstructor(RB_TREE_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(RB_TREE_MAP::new);
+#endif
+			setPMapConstructor(RB_TREE_MAP::new);
+			setMapConstructor(RB_TREE_MAP::new);
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class RBTreeMapComparator extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public RBTreeMapComparator() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPErbTreeMap(Comparator.naturalOrder()));
+			setPArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, Comparator.naturalOrder()));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, Comparator.naturalOrder()));
+#endif
+			setPMapConstructor(T -> MAP.builder().rbTreeMap(T, Comparator.naturalOrder()));
+			setMapConstructor(T -> MAP.builder().rbTreeMap(T, Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> MAP.builder().rbTreeMap(CLASS_TYPE::compare));
+			setPArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, CLASS_TYPE::compare));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().rbTreeMap(K, V, CLASS_TYPE::compare));
+#endif
+			setPMapConstructor(T -> MAP.builder().rbTreeMap(T, CLASS_TYPE::compare));
+			setMapConstructor(T -> MAP.builder().rbTreeMap(T, CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class AVLTreeMap extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public AVLTreeMap() {
+			setSimpleConstructor(MAP.builder()::avlTreeMap);
+			setPArrayConstructor(AVL_TREE_MAP::new);
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor(AVL_TREE_MAP::new);
+#endif
+			setPMapConstructor(AVL_TREE_MAP::new);
+			setMapConstructor(AVL_TREE_MAP::new);
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class AVLTreeMapComparator extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public AVLTreeMapComparator() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEavlTreeMap(Comparator.naturalOrder()));
+			setPArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, Comparator.naturalOrder()));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, Comparator.naturalOrder()));
+#endif
+			setPMapConstructor(T -> MAP.builder().avlTreeMap(T, Comparator.naturalOrder()));
+			setMapConstructor(T -> MAP.builder().avlTreeMap(T, Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> MAP.builder().avlTreeMap(CLASS_TYPE::compare));
+			setPArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, CLASS_TYPE::compare));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> MAP.builder().avlTreeMap(K, V, CLASS_TYPE::compare));
+#endif
+			setPMapConstructor(T -> MAP.builder().avlTreeMap(T, CLASS_TYPE::compare));
+			setMapConstructor(T -> MAP.builder().avlTreeMap(T, CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	private static class HashStrategy implements STRATEGY KEY_STRING_GENERIC_TYPE {
+		static final HashStrategy INSTANCE = new HashStrategy();
+		@Override
+		public int hashCode(KEY_STRING_TYPE o) { return KEY_TO_HASH(o); }
+		@Override
+		public boolean equals(KEY_STRING_TYPE key, KEY_STRING_TYPE value) { return KEY_EQUALS(key, value); }
+	}
+	
+	public static class HashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public HashMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().map());
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).map());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).map());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).map());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).map());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).map());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class LinkedHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public LinkedHashMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().linkedMap());
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).linkedMap());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).linkedMap());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).linkedMap());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).linkedMap());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).linkedMap());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class CustomHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public CustomHashMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().customMap(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).customMap(HashStrategy.INSTANCE));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customMap(HashStrategy.INSTANCE));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customMap(HashStrategy.INSTANCE));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customMap(HashStrategy.INSTANCE));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customMap(HashStrategy.INSTANCE));
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class LinkedCustomHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public LinkedCustomHashMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().customLinkedMap(HashStrategy.INSTANCE));
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).customLinkedMap(HashStrategy.INSTANCE));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customLinkedMap(HashStrategy.INSTANCE));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).customLinkedMap(HashStrategy.INSTANCE));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customLinkedMap(HashStrategy.INSTANCE));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).customLinkedMap(HashStrategy.INSTANCE));
+
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ImmutableHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ImmutableHashMapBuilder() {			
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).immutable());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).immutable());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).immutable());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).immutable());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ConcurrentHashMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ConcurrentHashMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().concurrentMap());
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).concurrentMap());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).concurrentMap());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).concurrentMap());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).concurrentMap());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).concurrentMap());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class ArrayMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public ArrayMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().arrayMap());
+			setSizeConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(T).arrayMap());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).arrayMap());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).arrayMap());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).arrayMap());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).arrayMap());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class RBTreeMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public RBTreeMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class RBTreeMapComparatorBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public RBTreeMapComparatorBuilder() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap(Comparator.naturalOrder()));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(Comparator.naturalOrder()));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(Comparator.naturalOrder()));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(Comparator.naturalOrder()));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().rbTreeMap(CLASS_TYPE::compare));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(CLASS_TYPE::compare));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).rbTreeMap(CLASS_TYPE::compare));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(CLASS_TYPE::compare));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).rbTreeMap(CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class AVLTreeMapBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public AVLTreeMapBuilder() {
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap());
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap());
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap());
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap());
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap());
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	public static class AVLTreeMapComparatorBuilder extends FILE_KEY_TYPE2FILE_VALUE_TYPEMapConstructorTester KEY_VALUE_STRING_GENERIC_TYPE
+	{
+		public AVLTreeMapComparatorBuilder() {
+#if TYPE_OBJECT
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap(Comparator.naturalOrder()));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(Comparator.naturalOrder()));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(Comparator.naturalOrder()));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(Comparator.naturalOrder()));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(Comparator.naturalOrder()));
+#else
+			setSimpleConstructor(() -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().avlTreeMap(CLASS_TYPE::compare));
+			setPArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(CLASS_TYPE::compare));
+#if !TYPE_OBJECT || !VALUE_OBJECT
+			setArrayConstructor((K, V) -> putAll(MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart(), K, V).avlTreeMap(CLASS_TYPE::compare));
+#endif
+			setPMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(CLASS_TYPE::compare));
+			setMapConstructor(T -> MAP.builder(). KEY_VALUE_STRING_GENERIC_TYPEstart().putAll(T).avlTreeMap(CLASS_TYPE::compare));
+#endif
+		}
+		
+#if TYPE_OBJECT
+		@Override
+		protected String[] createKeyElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 0, 100);
+		}
+		
+#endif
+#if VALUE_OBJECT
+		@Override
+		protected String[] createValueElements() {
+			return Arrays.copyOfRange(StringSortTest.NAMES, 100, 200);
+		}
+		
+#endif
+	}
+	
+	private static MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE putAll(MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE cache, KEY_STRING_TYPE[] keys, VALUE_STRING_TYPE[] values) {
+		if(keys.length != values.length) throw new IllegalStateException("Keys & Values lengths must match");
+		for(int i = 0;i<keys.length;i++) {
+			cache.put(keys[i], values[i]);
+		}
+		return cache;
+	}
+#if !TYPE_OBJECT || !VALUE_OBJECT
+
+	private static MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE putAll(MAP.BuilderCache KEY_VALUE_STRING_GENERIC_TYPE cache, CLASS_STRING_TYPE[] keys, CLASS_STRING_VALUE_TYPE[] values) {
+		if(keys.length != values.length) throw new IllegalStateException("Keys & Values lengths must match");
+		for(int i = 0;i<keys.length;i++) {
+			cache.put(keys[i], values[i]);
+		}
+		return cache;
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/SimpleMapTestGenerator.template

@@ -0,0 +1,200 @@
+package speiger.src.testers.PACKAGE.impl.maps;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.CONCURRENT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
+import speiger.src.collections.objects.collections.ObjectIterable;
+#if TYPE_OBJECT || VALUE_OBJECT
+import speiger.src.collections.objects.utils.ObjectArrays;
+#endif
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_SORTED_MAP_GENERATOR;
+import speiger.src.testers.objects.utils.ObjectSamples;
+
+@SuppressWarnings("javadoc")
+public class SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<E extends MAP KEY_VALUE_GENERIC_TYPE>
+{
+	BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper;
+#if TYPE_BYTE
+	KEY_TYPE[] keys = new KEY_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
+#else if TYPE_SHORT
+	KEY_TYPE[] keys = new KEY_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
+#else if TYPE_CHAR
+	KEY_TYPE[] keys = new KEY_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
+#else if TYPE_OBJECT
+	KEY_TYPE[] keys;
+#else
+	KEY_TYPE[] keys = new KEY_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
+#endif
+#if VALUE_BOOLEAN
+	VALUE_TYPE[] values = new VALUE_TYPE[]{true, true, true, false, true, false, true, false, true};
+#else if VALUE_BYTE
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(byte)0, (byte)1, (byte)2, (byte)3, (byte)4, (byte)-2, (byte)-1, (byte)5, (byte)6};
+#else if VALUE_SHORT
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(short)0, (short)1, (short)2, (short)3, (short)4, (short)-2, (short)-1, (short)5, (short)6};
+#else if VALUE_CHAR
+	VALUE_TYPE[] values = new VALUE_TYPE[]{(char)0, (char)1, (char)2, (char)3, (char)4};
+#else if VALUE_OBJECT
+	VALUE_TYPE[] values;
+#else
+	VALUE_TYPE[] values = new VALUE_TYPE[]{0, 1, 2, 3, 4, -2, -1, 5, 6};
+#endif
+	
+	public SIMPLE_MAP_TEST_GENERATOR(BiFunction<KEY_TYPE[], VALUE_TYPE[], E> mapper) {
+		this.mapper = mapper;
+	}
+	
+#if TYPE_OBJECT || TYPE_CHAR
+	public void setKeys(KEY_TYPE... keys) {
+		this.keys = keys;
+	}
+	
+#endif
+#if VALUE_OBJECT || VALUE_CHAR
+	public void setValues(VALUE_TYPE... values) {
+		this.values = values;
+	}
+	
+#endif
+	public ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSamples() {
+		return new ObjectSamples<MAP.Entry KEY_VALUE_GENERIC_TYPE>(
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[0], values[0]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[1], values[1]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[2], values[2]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[3], values[3]),
+			new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[4], values[4])
+		);
+	}
+	
+	public E create(MAP.Entry KEY_VALUE_GENERIC_TYPE... elements) {
+#if TYPE_OBJECT
+		KEY_TYPE[] keys = (T[])ObjectArrays.newArray(getSamples().e0().ENTRY_KEY().getClass(), elements.length);
+#else
+		KEY_TYPE[] keys = NEW_KEY_ARRAY(elements.length);
+#endif
+#if VALUE_OBJECT
+		VALUE_TYPE[] values = (V[])ObjectArrays.newArray(getSamples().e0().ENTRY_VALUE().getClass(), elements.length);
+#else
+		VALUE_TYPE[] values = NEW_VALUE_ARRAY(elements.length);
+#endif
+		for(int i = 0;i<elements.length;i++) {
+			keys[i] = elements[i].ENTRY_KEY();
+			values[i] = elements[i].ENTRY_VALUE();
+		}
+		return mapper.apply(keys, values);
+	}
+	
+	public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+		return insertionOrder;
+	}
+	
+	public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+		return insertionOrder;
+	}
+	
+	public static class Maps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		public Maps(BiFunction<KEY_TYPE[], VALUE_TYPE[], MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+	public static class OrderedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<ORDERED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		public OrderedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], ORDERED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+			super(mapper);
+		}
+	}
+	
+	public static class ConcurrentMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter; 
+		
+		public ConcurrentMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE> mapper, Consumer<ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE>> sorter) {
+			super(mapper);
+			this.sorter = sorter;
+		}
+		
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+			ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> newList = new ObjectArrayList<>();
+			for(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry : insertionOrder) {
+				newList.add(new ABSTRACT_MAP.BasicEntryKV_BRACES(entry.getKey(), entry.getValue()));
+			}
+			order(newList);
+			insertionOrder.sort(new Comparator<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>() {
+				@Override
+				public int compare(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> key, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> value) {
+					return Integer.signum(indexOf(OBJ_TO_KEY(key.getKey())) - indexOf(OBJ_TO_KEY(value.getKey())));
+				}
+				
+				protected int indexOf(KEY_TYPE key) {
+					for(int i = 0,m=newList.size();i<m;i++) {
+						if(KEY_EQUALS(newList.get(i).ENTRY_KEY(), key)) return i;
+					}
+					throw new IllegalArgumentException("MAP.entry sorter was corrupting data");
+				}
+			});
+			return insertionOrder;
+		}
+		
+		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+			sorter.accept(insertionOrder);
+			return insertionOrder;
+		}
+	}
+	
+	public static class SortedMaps KEY_VALUE_GENERIC_TYPE extends SIMPLE_MAP_TEST_GENERATOR KEY_VALUE_SPECIAL_GENERIC_TYPE<SORTED_MAP KEY_VALUE_GENERIC_TYPE> implements TEST_SORTED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
+	{
+		public SortedMaps(BiFunction<KEY_TYPE[], VALUE_TYPE[], SORTED_MAP KEY_VALUE_GENERIC_TYPE> mapper) {
+			super(mapper);
+#if TYPE_CHAR
+			setKeys(new KEY_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
+#endif
+#if VALUE_CHAR
+			setValues(new VALUE_TYPE[]{'a', 'b', 'c', 'd', 'e', '_', '`', 'f', 'g'});
+#endif
+
+		}
+		
+		public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
+#if TYPE_OBJECT
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator((Comparator<T>)Comparator.naturalOrder()));
+#else
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryObjectComparator(CLASS_TYPE::compare));
+#endif
+			return insertionOrder;
+		}
+		
+		public ObjectIterable<MAP.Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
+#if TYPE_OBJECT
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator((Comparator<T>)Comparator.naturalOrder()));
+#else
+			insertionOrder.sort(DERIVED_MAP_GENERATORS.entryComparator(CLASS_TYPE::compare));
+#endif
+			return insertionOrder;
+		}
+		
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[5], values[5]); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE belowSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[6], values[6]); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesLesser() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[7], values[7]); }
+		@Override
+		public MAP.Entry KEY_VALUE_GENERIC_TYPE aboveSamplesGreater() { return new ABSTRACT_MAP.BasicEntryKV_BRACES(keys[8], values[8]); }
+	}
+}

src/builder/resources/speiger/assets/testers/templates/impl/maps/TestMap.template

@@ -0,0 +1,92 @@
+package speiger.src.testers.PACKAGE.impl.maps;
+
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.PACKAGE.maps.impl.misc.ARRAY_MAP;
+import speiger.src.collections.objects.collections.ObjectIterator;
+import speiger.src.collections.objects.sets.AbstractObjectSet;
+import speiger.src.collections.objects.sets.ObjectSet;
+
+@SuppressWarnings("javadoc")
+public class SIMPLE_TEST_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE
+{
+	MAP KEY_VALUE_GENERIC_TYPE map;
+	
+	public SIMPLE_TEST_MAP(KEY_TYPE[] keys, VALUE_TYPE[] values) {
+		map = new ARRAY_MAPKV_BRACES(keys, values);
+	}
+	
+	@Override
+	public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
+		map.setDefaultReturnValue(v);
+		return this;
+	}
+	
+	@Override
+	public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
+	
+	@Override
+	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
+	@Override
+	public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
+#if VALUE_PRIMITIVES
+	@Override
+	public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
+	@Override
+	public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
+#endif
+	@Override
+	public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
+	@Override
+	public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
+#if !TYPE_OBJECT || !VALUE_OBJECT
+	@Override
+	public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
+#endif
+	@Override
+	public CLASS_VALUE_TYPE remove(Object key) { return map.remove(key); }
+	@Override
+	public boolean remove(Object key, Object value) { return map.remove(key, value); }
+	@Override
+	public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
+#if TYPE_OBJECT && !VALUE_OBJECT
+	@Override
+	public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
+#endif
+	@Override
+	public ObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
+		return new AbstractObjectSet<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
+			@Override
+			public ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
+				return new ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE>() {
+					ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iter = map.ENTRY_SET().iterator();
+					@Override
+					public boolean hasNext() {
+						return iter.hasNext();
+					}
+					
+					@Override
+					public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
+						MAP.Entry KEY_VALUE_GENERIC_TYPE entry = iter.next();
+						return new ABSTRACT_MAP.BasicEntry KEY_VALUE_GENERIC_TYPE(entry.ENTRY_KEY(), entry.ENTRY_VALUE()) {
+							@Override
+							public VALUE_TYPE setValue(VALUE_TYPE value) {
+								return entry.setValue(value);
+							}
+						};
+					}
+					
+					@Override
+					public void remove() {
+						iter.remove();
+					}
+				};
+			}
+			
+			@Override
+			public int size() {
+				return map.size();
+			}
+		};
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractCollectionTester.template

@@ -0,0 +1,28 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE extends ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<COLLECTION KEY_CLASS_GENERIC_TYPE>
+{
+	protected COLLECTION KEY_GENERIC_TYPE collection;
+
+	@Override
+	protected COLLECTION KEY_GENERIC_TYPE actualContents() {
+		return collection;
+	}
+
+	@Override
+	protected COLLECTION KEY_GENERIC_TYPE resetContainer(COLLECTION KEY_GENERIC_TYPE newContents) {
+		collection = super.resetContainer(newContents);
+		return collection;
+	}
+
+	protected void resetCollection() {
+		resetContainer();
+	}
+
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractContainerTester.template

@@ -0,0 +1,188 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+import com.google.common.collect.testing.AbstractTester;
+import com.google.common.collect.testing.OneSizeTestContainerGenerator;
+import com.google.common.collect.testing.TestContainerGenerator;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.errorprone.annotations.OverridingMethodsMustInvokeSuper;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.testers.PACKAGE.generators.TEST_COLLECTION_GENERATOR;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public abstract class ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<E> extends AbstractTester<OneSizeTestContainerGenerator<E, CLASS_TYPE>>
+{
+	protected SAMPLE_ELEMENTS KEY_GENERIC_TYPE samples;
+	protected E container;
+	protected TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE primitiveGenerator;
+	protected CollectionSize size;
+
+	@Override
+	@OverridingMethodsMustInvokeSuper
+	public void setUp() throws Exception {
+		super.setUp();
+		setupGenerator();
+	}
+	
+	protected void setupGenerator() {
+		TestContainerGenerator<E, CLASS_TYPE> generator = getSubjectGenerator().getInnerGenerator();
+		if (!(generator instanceof TEST_COLLECTION_GENERATOR)) throw new IllegalStateException("Test Generator Must extend TEST_COLLECTION_GENERATOR");
+		primitiveGenerator = (TEST_COLLECTION_GENERATOR KEY_GENERIC_TYPE) generator;
+		samples = primitiveGenerator.getSamples();
+		size = getSubjectGenerator().getCollectionSize();
+		resetContainer();		
+	}
+
+	protected abstract COLLECTION KEY_GENERIC_TYPE actualContents();
+
+	protected E resetContainer() {
+		return resetContainer(createTestSubject());
+	}
+
+	protected E resetContainer(E newValue) {
+		container = newValue;
+		return container;
+	}
+
+	protected void expectContents(KEY_TYPE... elements) {
+		expectContents(ARRAY_LIST.wrap(elements));
+	}
+
+	protected void expectContents(COLLECTION KEY_GENERIC_TYPE expected) {
+		HELPERS.assertEqualIgnoringOrder(expected, actualContents());
+	}
+
+	protected void expectUnchanged() {
+		expectContents(getOrderedElements());
+	}
+
+	protected final void expectAdded(KEY_TYPE... elements) {
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
+		expected.addAll(elements);
+		expectContents(expected);
+	}
+
+	protected final void expectAddedIndex(int index, KEY_TYPE... elements) {
+		expectAdded(index, ARRAY_LIST.wrap(elements));
+	}
+
+	protected final void expectAdded(int index, COLLECTION KEY_GENERIC_TYPE elements) {
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getSampleElements());
+		expected.addAll(index, elements);
+		expectContents(expected);
+	}
+
+	protected void expectMissing(KEY_TYPE... elements) {
+		for (KEY_TYPE element : elements) {
+			assertFalse("Should not contain " + element, actualContents().contains(element));
+		}
+	}
+
+	protected KEY_TYPE[] createSamplesArray() {
+		return getSampleElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
+	}
+
+	protected KEY_TYPE[] createOrderedArray() {
+		return getOrderedElements().TO_ARRAY(NEW_KEY_ARRAY(getNumElements()));
+	}
+
+	public static class ArrayWithDuplicate KEY_GENERIC_TYPE {
+		public final KEY_TYPE[] elements;
+		public final KEY_TYPE duplicate;
+
+		private ArrayWithDuplicate(KEY_TYPE[] elements, KEY_TYPE duplicate) {
+			this.elements = elements;
+			this.duplicate = duplicate;
+		}
+	}
+
+	protected ArrayWithDuplicate KEY_GENERIC_TYPE createArrayWithDuplicateElement() {
+		KEY_TYPE[] elements = createSamplesArray();
+		KEY_TYPE duplicate = elements[(elements.length / 2) - 1];
+		elements[(elements.length / 2) + 1] = duplicate;
+		return new ArrayWithDuplicateBRACES(elements, duplicate);
+	}
+
+	protected int getNumElements() {
+		return size.getNumElements();
+	}
+
+	protected COLLECTION KEY_GENERIC_TYPE getSampleElements() {
+		return getSampleElements(getNumElements());
+	}
+
+	protected LIST KEY_GENERIC_TYPE getOrderedElements() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		for (ITERATOR KEY_GENERIC_TYPE iter = primitiveGenerator.order(new ARRAY_LISTBRACES(getSampleElements())).iterator(); iter.hasNext();) {
+			list.add(iter.NEXT());
+		}
+		return LISTS.unmodifiable(list);
+	}
+	
+#if TYPE_OBJECT
+	protected KEY_TYPE[] createDisjointArray() {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(2);
+		array[0] = e3();
+		array[1] = e4();
+		return array;
+	}
+#else
+	protected KEY_TYPE[] createDisjointArray() {
+		return new KEY_TYPE[]{e3(), e4()};
+	}
+	
+#endif	
+	protected KEY_TYPE[] emptyArray() {
+		return NEW_KEY_ARRAY(0);
+	}
+	
+	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE createDisjointCollection() {
+		return MINIMAL_COLLECTION.of(e3(), e4());
+	}
+	
+	protected MINIMAL_COLLECTION KEY_GENERIC_TYPE emptyCollection() {
+		return MINIMAL_COLLECTION.of();
+	}
+	
+	public KEY_TYPE[] createArray(KEY_TYPE...array) {
+		return array;
+	}
+	
+	protected final KEY_TYPE e0() {
+		return samples.e0();
+	}
+
+	protected final KEY_TYPE e1() {
+		return samples.e1();
+	}
+
+	protected final KEY_TYPE e2() {
+		return samples.e2();
+	}
+
+	protected final KEY_TYPE e3() {
+		return samples.e3();
+	}
+
+	protected final KEY_TYPE e4() {
+		return samples.e4();
+	}
+
+	protected E createTestSubject() {
+		return (E)primitiveGenerator.create(getSampleElements(size.getNumElements()).TO_ARRAY(NEW_KEY_ARRAY(getNumElements())));
+	}
+
+	protected COLLECTION KEY_GENERIC_TYPE getSampleElements(int howMany) {
+		return new ARRAY_LISTBRACES(samples.asList().subList(0, howMany));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractListIndexOfTester.template

@@ -0,0 +1,27 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public abstract class ABSTRACT_LIST_INDEX_OF_TESTER KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+	protected abstract int find(KEY_TYPE o);
+	
+	protected abstract String getMethodName();
+	
+	@CollectionSize.Require(absent = ZERO)
+	public void testFind_yes() {
+		assertEquals(getMethodName() + "(firstElement) should return 0", 0, find(getOrderedElements().GET_KEY(0)));
+	}
+	
+	public void testFind_no() {
+		assertEquals(getMethodName() + "(notPresent) should return -1", -1, find(e3()));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractListTester.template

@@ -0,0 +1,39 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+import org.junit.Ignore;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	protected final LIST KEY_GENERIC_TYPE getList() {
+		return (LIST KEY_GENERIC_TYPE) collection;
+	}
+
+	@Override
+	protected void expectContents(COLLECTION KEY_GENERIC_TYPE expectedCollection) {
+		LIST KEY_GENERIC_TYPE expectedList = HELPERS.copyToList(expectedCollection);
+		if (getList().size() != expectedList.size()) {
+			fail("size mismatch: " + reportContext(expectedList));
+		}
+		for (int i = 0; i < expectedList.size(); i++) {
+			KEY_TYPE expected = expectedList.GET_KEY(i);
+			KEY_TYPE actual = getList().GET_KEY(i);
+			if (KEY_EQUALS_NOT(expected, actual)) {
+				fail("mismatch at index " + i + ": " + reportContext(expectedList));
+			}
+		}
+	}
+
+	private String reportContext(LIST KEY_GENERIC_TYPE expected) {
+		return String.format("expected collection %s; actual collection %s", expected, collection);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractQueueTester.template

@@ -0,0 +1,81 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.TestContainerGenerator;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.queues.PRIORITY_QUEUE;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.testers.PACKAGE.generators.TEST_QUEUE_GENERATOR;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class ABSTRACT_QUEUE_TESTER KEY_GENERIC_TYPE extends ABSTRACT_CONTAINER_TESTER KKS_GENERIC_TYPE<PRIORITY_QUEUE KEY_CLASS_GENERIC_TYPE>
+{
+	protected TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE queueGenerator;
+	protected PRIORITY_QUEUE KEY_GENERIC_TYPE queue;
+	
+	@Override
+	protected void setupGenerator() {
+		TestContainerGenerator<PRIORITY_QUEUE KEY_GENERIC_TYPE, CLASS_TYPE> generator = getSubjectGenerator().getInnerGenerator();
+		if (!(generator instanceof TEST_QUEUE_GENERATOR)) throw new IllegalStateException("Test Generator Must extend TestLongCollectionGenerator");
+		queueGenerator = (TEST_QUEUE_GENERATOR KEY_GENERIC_TYPE) generator;
+		samples = queueGenerator.getSamples();
+		size = getSubjectGenerator().getCollectionSize();
+		resetContainer();		
+	}
+	
+	@Override
+	protected COLLECTION KEY_GENERIC_TYPE actualContents() { return null; }
+	
+	@Override
+	protected PRIORITY_QUEUE KEY_GENERIC_TYPE resetContainer(PRIORITY_QUEUE KEY_GENERIC_TYPE newValue) {
+		queue = super.resetContainer(newValue);
+		return queue;
+	}
+	
+	protected void resetQueue() {
+		resetContainer();
+	}
+	
+	protected LIST KEY_GENERIC_TYPE getOrderedElements() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		for (ITERATOR KEY_GENERIC_TYPE iter = queueGenerator.order(new ARRAY_LISTBRACES(getSampleElements())).iterator(); iter.hasNext();) {
+			list.add(iter.NEXT());
+		}
+		return LISTS.unmodifiable(list);
+	}
+	
+	@Override
+	protected PRIORITY_QUEUE KEY_GENERIC_TYPE createTestSubject() {
+		return queueGenerator.create(getSampleElements(size.getNumElements()).TO_ARRAY(NEW_KEY_ARRAY(getNumElements())));
+	}
+	
+	@Override
+	protected void expectContents(COLLECTION KEY_GENERIC_TYPE expected) {
+		HELPERS.assertContentsAnyOrder(expected, queue.TO_ARRAY());
+	}
+	
+	@Override
+	protected void expectMissing(KEY_TYPE... elements) {
+		for (KEY_TYPE element : elements) {
+			assertFalse("Should not contain " + element, contains(element));
+		}
+	}
+	
+	protected boolean contains(KEY_TYPE element) {
+		for(int i = 0,m=queue.size();i<m;i++) {
+			if(KEY_EQUALS(queue.peek(i), element)) return true;
+		}
+		return false;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractSetTester.template

@@ -0,0 +1,14 @@
+package speiger.src.testers.PACKAGE.tests.base;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.sets.SET;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class ABSTRACT_SET_TESTER KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	protected final SET KEY_GENERIC_TYPE getSet() {
+		return (SET KEY_GENERIC_TYPE)collection;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/base/maps/AbstractMapTester.template

@@ -0,0 +1,243 @@
+package speiger.src.testers.PACKAGE.tests.base.maps;
+
+import java.util.Locale;
+import java.util.Map;
+#if VALUE_OBJECT
+import java.util.Objects;
+#endif
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.TestContainerGenerator;
+
+import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
+import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
+import speiger.src.collections.objects.collections.ObjectCollection;
+import speiger.src.collections.objects.collections.ObjectIterator;
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.collections.objects.lists.ObjectListIterator;
+import speiger.src.collections.objects.utils.ObjectLists;
+import speiger.src.testers.PACKAGE.generators.maps.TEST_MAP_GENERATOR;
+#if !TYPE_OBJECT
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+#endif
+import speiger.src.testers.objects.tests.base.AbstractObjectContainerTester;
+import speiger.src.testers.objects.utils.ObjectHelpers;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class ABSTRACT_MAP_TESTER KEY_VALUE_GENERIC_TYPE extends AbstractObjectContainerTester<MAP.Entry KEY_VALUE_GENERIC_TYPE, MAP KEY_VALUE_GENERIC_TYPE>
+{
+	protected TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE primitiveMapGenerator;
+
+	protected MAP KEY_VALUE_GENERIC_TYPE getMap() {
+		return container;
+	}
+
+	@Override
+	protected void setupGenerator() {
+		TestContainerGenerator<? extends Map<CLASS_TYPE, CLASS_VALUE_TYPE>, ? extends Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> generator = getSubjectGenerator().getInnerGenerator();
+		if (!(generator instanceof TEST_MAP_GENERATOR)) throw new IllegalStateException("Test Generator Must extend TestLong2ByteMapGenerator");
+		primitiveMapGenerator = (TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) generator;
+		samples = primitiveMapGenerator.getSamples();
+		size = getSubjectGenerator().getCollectionSize();
+		resetContainer();
+	}
+	
+	@Override
+	protected MAP KEY_VALUE_GENERIC_TYPE createTestSubject() {
+		return primitiveMapGenerator.create(getSampleElements(size.getNumElements()).toArray(new MAP.Entry[getNumElements()]));
+	}
+	
+	@Override
+	protected ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> getOrderedElements() {
+		ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> list = new ObjectArrayList<>();
+		for (ObjectIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iter = primitiveMapGenerator.order(new ObjectArrayList<MAP.Entry KEY_VALUE_GENERIC_TYPE>(getSampleElements())).iterator(); iter.hasNext();) {
+			list.add(iter.next());
+		}
+		return ObjectLists.unmodifiable(list);
+	}
+	
+	@Override
+	protected ObjectCollection<MAP.Entry KEY_VALUE_GENERIC_TYPE> actualContents() {
+		return getMap().ENTRY_SET();
+	}
+
+	protected final void resetMap() {
+		resetContainer();
+	}
+
+	protected void resetMap(MAP.Entry KEY_VALUE_GENERIC_TYPE[] entries) {
+		resetContainer(primitiveMapGenerator.create(entries));
+	}
+	
+	@Override
+	protected MAP KEY_VALUE_GENERIC_TYPE resetContainer(MAP KEY_VALUE_GENERIC_TYPE newValue) {
+		newValue.setDefaultReturnValue(INVALID_VALUE);
+		return super.resetContainer(newValue);
+	}
+
+	protected void expectMissingKeys(KEY_TYPE... elements) {
+		for (KEY_TYPE element : elements) {
+			assertFalse("Should not contain key " + element, getMap().containsKey(element));
+		}
+	}
+
+	protected void expectMissingValues(VALUE_TYPE... elements) {
+		for (VALUE_TYPE element : elements) {
+			assertFalse("Should not contain value " + element, getMap().containsValue(element));
+		}
+	}
+	
+	protected int getNumEntries() {
+		return getNumElements();
+	}
+		
+	protected ObjectCollection<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSampleEntries(int howMany) {
+		return getSampleElements(howMany);
+	}
+
+	protected ObjectCollection<MAP.Entry KEY_VALUE_GENERIC_TYPE> getSampleEntries() {
+		return getSampleElements();
+	}
+
+	@Override
+	protected void expectMissing(MAP.Entry KEY_VALUE_GENERIC_TYPE... entries) {
+		for (MAP.Entry KEY_VALUE_GENERIC_TYPE entry : entries) {
+			assertFalse("Should not contain entry " + entry, actualContents().contains(entry));
+#if !VALUE_BOOLEAN
+			assertFalse("Should not contain key " + entry.ENTRY_KEY() + " mapped to value " + entry.ENTRY_VALUE(), valueEquals(getMap().get(entry.ENTRY_KEY()), entry.ENTRY_VALUE()));
+#endif
+		}
+	}
+
+	@Override
+	protected void expectContents(ObjectCollection<MAP.Entry KEY_VALUE_GENERIC_TYPE> expected) {
+		super.expectContents(expected);
+		for (MAP.Entry KEY_VALUE_GENERIC_TYPE entry : expected) {
+			assertEquals("Wrong value for key " + entry.ENTRY_KEY(), entry.ENTRY_VALUE(), getMap().GET_VALUE(entry.ENTRY_KEY()));
+		}
+	}
+
+	protected final void expectReplacement(MAP.Entry KEY_VALUE_GENERIC_TYPE newEntry) {
+		ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> expected = ObjectHelpers.copyToList(getSampleElements());
+		replaceValue(expected, newEntry);
+		expectContents(expected);
+	}
+
+	private void replaceValue(ObjectList<MAP.Entry KEY_VALUE_GENERIC_TYPE> expected, MAP.Entry KEY_VALUE_GENERIC_TYPE newEntry) {
+		for (ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> i = expected.listIterator(); i.hasNext();) {
+			if (HELPERS.equals(i.next().ENTRY_KEY(), newEntry.ENTRY_KEY())) {
+				i.set(newEntry);
+				return;
+			}
+		}
+		throw new IllegalArgumentException(String.format(Locale.ROOT, "key %s not found in entries %s", newEntry.ENTRY_KEY(), expected));
+	}
+	
+#if !VALUE_BOOLEAN
+	private static GENERIC_VALUE_BRACES boolean valueEquals(VALUE_TYPE a, VALUE_TYPE b) {
+		return VALUE_EQUALS(a, b);
+	}
+	
+#endif
+	protected MAP.Entry KEY_VALUE_GENERIC_TYPE entry(KEY_TYPE key, VALUE_TYPE value) {
+		return new ABSTRACT_MAP.BasicEntryKV_BRACES(key, value);
+	}
+	
+	protected KEY_TYPE[] emptyKeyArray() {
+		return NEW_KEY_ARRAY(0);
+	}
+	
+	protected KEY_TYPE[] createDisjointedKeyArray() {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(2);
+		array[0] = k3();
+		array[1] = k4();
+		return array;
+	}
+	
+	protected CLASS_TYPE[] emptyKeyObjectArray() {
+		return NEW_CLASS_ARRAY(0);
+	}
+	
+	protected CLASS_TYPE[] createDisjointedKeyObjectArray() {
+		CLASS_TYPE[] array = NEW_CLASS_ARRAY(2);
+		array[0] = k3();
+		array[1] = k4();
+		return array;
+	}
+	
+	protected VALUE_TYPE[] emptyValueArray() {
+		return NEW_VALUE_ARRAY(0);
+	}
+	
+	protected VALUE_TYPE[] createDisjointedValueArray() {
+		VALUE_TYPE[] array = NEW_VALUE_ARRAY(2);
+		array[0] = v3();
+		array[1] = v4();
+		return array;
+	}
+	
+	protected CLASS_VALUE_TYPE[] emptyValueObjectArray() {
+		return NEW_CLASS_VALUE_ARRAY(0);
+	}
+	
+	protected CLASS_VALUE_TYPE[] createDisjointedValueObjectArray() {
+		CLASS_VALUE_TYPE[] array = NEW_CLASS_VALUE_ARRAY(2);
+		array[0] = v3();
+		array[1] = v4();
+		return array;
+	}
+	
+	protected VALUE_TYPE get(KEY_TYPE key) {
+		return getMap().GET_VALUE(key);
+	}
+	
+#if !TYPE_OBJECT
+	@SuppressWarnings("deprecation")
+	protected CLASS_VALUE_TYPE get(CLASS_TYPE key) {
+		return getMap().get(key);
+	}
+	
+#endif
+	protected final KEY_TYPE k0() {
+		return e0().ENTRY_KEY();
+	}
+
+	protected final VALUE_TYPE v0() {
+		return e0().ENTRY_VALUE();
+	}
+
+	protected final KEY_TYPE k1() {
+		return e1().ENTRY_KEY();
+	}
+
+	protected final VALUE_TYPE v1() {
+		return e1().ENTRY_VALUE();
+	}
+
+	protected final KEY_TYPE k2() {
+		return e2().ENTRY_KEY();
+	}
+
+	protected final VALUE_TYPE v2() {
+		return e2().ENTRY_VALUE();
+	}
+
+	protected final KEY_TYPE k3() {
+		return e3().ENTRY_KEY();
+	}
+
+	protected final VALUE_TYPE v3() {
+		return e3().ENTRY_VALUE();
+	}
+
+	protected final KEY_TYPE k4() {
+		return e4().ENTRY_KEY();
+	}
+
+	protected final VALUE_TYPE v4() {
+		return e4().ENTRY_VALUE();
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddAllArrayTester.template

@@ -0,0 +1,151 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionAddAllArrayTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	public void testAddAllArray_supportedNothing() {
+		assertFalse("addAll(nothing[]) should return false", collection.addAll(emptyArray()));
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	public void testAddAllArray_unsupportedNothing() {
+		try {
+			assertFalse("addAll(nothing[]) should return false or throw", collection.addAll(emptyArray()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	public void testAddAllArray_supportedNonePresent() {
+		assertTrue("addAll(nonePresent[]) should return true", collection.addAll(createDisjointArray()));
+		expectAdded(e3(), e4());
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	public void testAddAllArray_unsupportedNonePresent() {
+		try {
+			collection.addAll(createDisjointArray());
+			fail("addAll(nonePresent[]) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+#endignore
+	
+#if !TYPE_BOOLEAN
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedToLargeOffset() {
+		try {
+			collection.addAll(createDisjointArray(), 5, 2);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedToLargeArray() {
+		try {
+			collection.addAll(createDisjointArray(), 3);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedToSmallOffset() {
+		try {
+			collection.addAll(createDisjointArray(), -1, 2);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedAddSubArray() {
+		try {
+			collection.addAll(createDisjointArray(), 1);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectAdded(e3());
+		expectMissing(e4());
+	}
+#endif
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAllArray_supportedSomePresent() {
+		assertTrue("addAll(somePresent[]) should return true", collection.addAll(e3(), e0()));
+		assertTrue("should contain " + e3(), collection.contains(e3()));
+		assertTrue("should contain " + e0(), collection.contains(e0()));
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAllArray_unsupportedSomePresent() {
+		try {
+			collection.addAll(e3(), e0());
+			fail("addAll(somePresent[]) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require({ SUPPORTS_ADD, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAllArrayConcurrentWithIteration() {
+#endignore
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			assertTrue(collection.addAll(e3(), e0()));
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAllArray_unsupportedAllPresent() {
+		try {
+			assertFalse("addAll(allPresent[]) should return false or throw", collection.addAll(e0()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddAllTester.template

@@ -0,0 +1,102 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionAddAllTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	public void testAddAll_supportedNothing() {
+		assertFalse("addAll(nothing) should return false", collection.addAll(emptyCollection()));
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	public void testAddAll_unsupportedNothing() {
+		try {
+			assertFalse("addAll(nothing) should return false or throw", collection.addAll(emptyCollection()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	public void testAddAll_supportedNonePresent() {
+		assertTrue("addAll(nonePresent) should return true", collection.addAll(createDisjointCollection()));
+		expectAdded(e3(), e4());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	public void testAddAll_unsupportedNonePresent() {
+		try {
+			collection.addAll(createDisjointCollection());
+			fail("addAll(nonePresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAll_supportedSomePresent() {
+#endignore
+		assertTrue("addAll(somePresent) should return true", collection.addAll(MINIMAL_COLLECTION.of(e3(), e0())));
+		assertTrue("should contain " + e3(), collection.contains(e3()));
+		assertTrue("should contain " + e0(), collection.contains(e0()));
+	}
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAll_unsupportedSomePresent() {
+#endignore
+		try {
+			collection.addAll(MINIMAL_COLLECTION.of(e3(), e0()));
+			fail("addAll(somePresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require({ SUPPORTS_ADD, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAllConcurrentWithIteration() {
+#endignore
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			assertTrue(collection.addAll(MINIMAL_COLLECTION.of(e3(), e0())));
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAll_unsupportedAllPresent() {
+		try {
+			assertFalse("addAll(allPresent) should return false or throw", collection.addAll(MINIMAL_COLLECTION.of(e0())));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddTester.template

@@ -0,0 +1,64 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionAddTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	public void testAdd_supportedNotPresent() {
+		assertTrue("add(notPresent) should return true", collection.add(e3()));
+		expectAdded(e3());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	public void testAdd_unsupportedNotPresent() {
+		try {
+			collection.add(e3());
+			fail("add(notPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAdd_unsupportedPresent() {
+		try {
+			assertFalse("add(present) should return false or throw", collection.add(e0()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require({ SUPPORTS_ADD, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddConcurrentWithIteration() {
+#endignore
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			assertTrue(collection.add(e3()));
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionClearTester.template

@@ -0,0 +1,68 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionClearTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	public void testClear() {
+		collection.clear();
+		assertTrue("After clear(), a collection should be empty.", collection.isEmpty());
+		assertEquals(0, collection.size());
+		assertFalse(collection.iterator().hasNext());
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testClear_unsupported() {
+		try {
+			collection.clear();
+			fail("clear() should throw UnsupportedOperation if a collection does "
+					+ "not support it and is not empty.");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testClear_unsupportedByEmptyCollection() {
+		try {
+			collection.clear();
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require({ SUPPORTS_REMOVE, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(SEVERAL)
+	public void testClearConcurrentWithIteration() {
+#endignore
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			collection.clear();
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionConstructorTester.template

@@ -0,0 +1,165 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.Supplier;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Ignore;
+import junit.framework.TestCase;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+#if !TYPE_OBJECT
+import speiger.src.collections.PACKAGE.utils.ARRAYS;
+#endif
+import speiger.src.collections.utils.ITrimmable;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public abstract class FILE_KEY_TYPECollectionConstructorTester KEY_GENERIC_TYPE extends TestCase
+{
+	protected Supplier<COLLECTION KEY_GENERIC_TYPE> simpleConstructor;
+	protected IntFunction<COLLECTION KEY_GENERIC_TYPE> sizeConstructor;
+	protected Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> pArrayConstructor;
+#if !TYPE_OBJECT
+	protected Function<CLASS_TYPE[], COLLECTION KEY_GENERIC_TYPE> arrayConstructor;
+#endif
+	protected Function<Collection<? extends CLASS_TYPE>, COLLECTION KEY_GENERIC_TYPE> collectionConstructor;
+	protected Function<COLLECTION KEY_GENERIC_TYPE, COLLECTION KEY_GENERIC_TYPE> pCollectionConstructor;
+	protected KEY_TYPE[] keys = createKeyElements();
+	
+	protected void setSimpleConstructor(Supplier<COLLECTION KEY_GENERIC_TYPE> simpleConstructor) {
+		this.simpleConstructor = simpleConstructor;
+	}
+	
+	protected void setSizeConstructor(IntFunction<COLLECTION KEY_GENERIC_TYPE> sizeConstructor) {
+		this.sizeConstructor = sizeConstructor;
+	}
+	
+	protected void setPArrayConstructor(Function<KEY_TYPE[], COLLECTION KEY_GENERIC_TYPE> pArrayConstructor) {
+		this.pArrayConstructor = pArrayConstructor;
+	}
+	
+#if !TYPE_OBJECT
+	protected void setArrayConstructor(Function<CLASS_TYPE[], COLLECTION KEY_GENERIC_TYPE> arrayConstructor) {
+		this.arrayConstructor = arrayConstructor;
+	}
+
+#endif
+	protected void setCollectionConstructor(Function<Collection<? extends CLASS_TYPE>, COLLECTION KEY_GENERIC_TYPE> collectionConstructor) {
+		this.collectionConstructor = collectionConstructor;
+	}
+	
+	protected void setPCollectionConstructor(Function<COLLECTION KEY_GENERIC_TYPE, COLLECTION KEY_GENERIC_TYPE> pCollectionConstructor) {
+		this.pCollectionConstructor = pCollectionConstructor;
+	}
+	
+	@Test
+	public void testPrimitiveArrayConstructor() {
+		if(pArrayConstructor == null) return;
+		Assert.assertTrue(pArrayConstructor.apply(keys) != null);
+	}
+	
+#if !TYPE_OBJECT
+	@Test
+	public void testArrayConstructor() {
+		if(arrayConstructor == null) return;
+#if TYPE_OBJECT
+		Assert.assertTrue(arrayConstructor.apply(keys) != null);
+#else
+		Assert.assertTrue(arrayConstructor.apply(ARRAYS.wrap(keys)) != null);
+#endif
+	}
+	
+#endif
+	@Test
+	public void testPrimitiveMapsConstructor() {
+		if(pCollectionConstructor == null) return;
+		Assert.assertTrue(pCollectionConstructor.apply(new ARRAY_LISTBRACES(keys)) != null);
+	}
+	
+	@Test
+	public void testMapsConstructor() {
+		if(collectionConstructor == null) return;
+		Assert.assertTrue(collectionConstructor.apply(new ArrayList<>(new ARRAY_LISTBRACES(keys))) != null);
+	}
+	
+	@Test
+	public void testSimpleConstructor() {
+		if(simpleConstructor == null) return;
+		Assert.assertTrue(simpleConstructor.get() != null);
+	}
+	
+	@Test
+	public void testSizeConstructor_empty() {
+		if(sizeConstructor == null) return;
+		Assert.assertTrue(sizeConstructor.apply(0) != null);
+	}
+	
+	@Test
+	public void testSizeConstructor_smallSize() {
+		if(sizeConstructor == null) return;
+		Assert.assertTrue(sizeConstructor.apply(32) != null);
+	}
+	
+	@Test
+	public void testSizeConstructor_largeSize() {
+		if(sizeConstructor == null) return;
+		Assert.assertTrue(sizeConstructor.apply(25212) != null);
+	}
+	
+	@Test
+	public void testRehash() {
+		if(sizeConstructor == null) return;
+		try
+		{
+			COLLECTION KEY_GENERIC_TYPE set = sizeConstructor.apply(0);
+			if(set instanceof ITrimmable) {
+				ITrimmable trim = (ITrimmable)set;
+				set.addAll(keys);
+				set.clear();
+				Assert.assertTrue(trim.trim());
+				Assert.assertFalse(trim.trim());
+				set.addAll(keys);
+				trim.clearAndTrim();
+				set.addAll(keys);
+				trim.clearAndTrim(Short.MAX_VALUE);
+			}
+		}
+		catch(UnsupportedOperationException e) {
+			//Ignore thats fine
+		}
+	}
+	
+	@Test
+	public void testSizeConstructor_InvalidSize() {
+		if(sizeConstructor == null) return;
+		try {
+			sizeConstructor.apply(-1);
+			Assert.fail("When Inputted Size is negative this should crash");
+		}
+		catch(IllegalStateException e) {
+		}
+	}
+	
+#if TYPE_OBJECT
+	protected abstract KEY_TYPE[] createKeyElements();
+	
+#else
+	protected KEY_TYPE[] createKeyElements() {
+		KEY_TYPE[] keys = NEW_KEY_ARRAY(100);
+		for(int i = 0;i<100;i++) {
+#if TYPE_BOOLEAN
+			keys[i] = i % 2 != 0;
+#else
+			keys[i] = (KEY_TYPE)i;
+#endif
+		}
+		return keys;
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsAllTester.template

@@ -0,0 +1,45 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionContainsAllTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testContainsAll_empty() {
+		assertTrue("containsAll(empty) should return true", collection.containsAll(MINIMAL_COLLECTION.of()));
+	}
+
+#ignore
+	@CollectionSize.Require(absent = ZERO)
+	public void testContainsAll_subset() {
+#endignore
+		assertTrue("containsAll(subset) should return true", collection.containsAll(MINIMAL_COLLECTION.of(e0())));
+	}
+
+	public void testContainsAll_sameElements() {
+		assertTrue("containsAll(sameElements) should return true", collection.containsAll(MINIMAL_COLLECTION.of(createSamplesArray())));
+	}
+	
+	public void testContainsAll_self() {
+		assertTrue("containsAll(this) should return true", collection.containsAll(collection));
+	}
+
+	public void testContainsAll_partialOverlap() {
+		assertFalse("containsAll(partialOverlap) should return false", collection.containsAll(MINIMAL_COLLECTION.of(e0(), e3())));
+	}
+
+	public void testContainsAll_disjoint() {
+		assertFalse("containsAll(disjoint) should return false", collection.containsAll(MINIMAL_COLLECTION.of(e3())));
+	}
+	
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsAnyTester.template

@@ -0,0 +1,42 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionContainsAnyTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{	
+	public void testContainsAny_empty() {
+		assertFalse("containsAny(empty) should return false", collection.containsAny(MINIMAL_COLLECTION.of()));
+	}
+#ignore
+	@CollectionSize.Require(absent = ZERO)
+	public void testContainsAny_subset() {
+#endignore
+		assertTrue("containsAny(subset) should return true", collection.containsAny(MINIMAL_COLLECTION.of(e0())));
+	}
+	
+#ignore
+	@CollectionSize.Require(ONE)
+	public void testContainsAny_subSetElement() {
+#endignore
+		assertFalse("containsAny(empty) should return false", collection.containsAny(MINIMAL_COLLECTION.of()));
+	}
+	
+#ignore
+	@CollectionSize.Require(ONE)
+	public void testContainsAny_subSetElements() {
+#endignore
+		assertTrue("containsAny(subset) should return true", collection.containsAny(getSampleElements(5)));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsTester.template

@@ -0,0 +1,27 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionContainsTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionSize.Require(absent = ZERO)
+	public void testContains_yes() {
+		assertTrue("contains(present) should return true", collection.contains(e0()));
+	}
+
+	public void testContains_no() {
+		assertFalse("contains(notPresent) should return false", collection.contains(e3()));
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionCopyTester.template

@@ -0,0 +1,38 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Assert;
+import org.junit.Ignore;
+
+import speiger.src.testers.utils.SpecialFeature;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionCopyTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@SpecialFeature.Require(SpecialFeature.COPYING)
+#endignore
+	public void testEquals() {
+		COLLECTION KEY_GENERIC_TYPE copy = collection.copy();
+		if(!(collection instanceof COLLECTIONS.EmptyCollection)) {
+			Assert.assertFalse("Copied Collection shouldn't match", copy == collection);
+		}
+		Assert.assertTrue("Copied Collection contents should match", copy.equals(collection));
+	}
+
+#ignore
+	@SpecialFeature.Require(absent = SpecialFeature.COPYING)
+#endignore
+	public void testEqualsFail() {
+		try {
+			assertNull(collection.copy());
+			fail("If Copying isn't supported it should throw a UnsupportedOperationException");
+		}
+		catch(UnsupportedOperationException e) {
+			//Success
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionEqualsTester.template

@@ -0,0 +1,24 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+import org.junit.Ignore;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionEqualsTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testEquals_self() {
+		assertTrue("An Object should be equal to itself.", collection.equals(collection));
+	}
+	
+	public void testEquals_null() {
+		// noinspection ObjectEqualsNull
+		assertFalse("An object should not be equal to null.", collection.equals(null));
+	}
+	
+	public void testEquals_notACollection() {
+		// noinspection EqualsBetweenInconvertibleTypes
+		assertFalse("A Collection should never equal an object that is not a Collection.", collection.equals("huh?"));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionForEachTester.template

@@ -0,0 +1,55 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionForEachTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(absent = KNOWN_ORDER)
+	public void testForEachUnknownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach(elements::add);
+		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
+	}
+	
+#ignore
+@CollectionFeature.Require(absent = KNOWN_ORDER)
+	public void testForEachExtraUnknownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach(elements, LIST::add);
+		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
+	}
+	
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testForEachKnownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach(elements::add);
+		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
+	}
+	
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testForEachExtraKnownOrder() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		collection.forEach(elements, LIST::add);
+		assertEquals("Different ordered iteration", HELPERS.copyToList(getOrderedElements()), elements);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionIteratorTester.template

@@ -0,0 +1,161 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.IteratorFeature.MODIFIABLE;
+import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ITERATOR_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.EnumSet;
+import java.util.Collections;
+
+import com.google.common.collect.testing.IteratorFeature;
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.ITERABLE;
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.ITERATOR_TESTER;
+import speiger.src.testers.PACKAGE.utils.LIST_ITERATOR_TESTER;
+import speiger.src.testers.PACKAGE.utils.BIDIRECTIONAL_ITERATOR_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionIteratorTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterator() {
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		for (ITERATOR KEY_GENERIC_TYPE iter = collection.iterator();iter.hasNext();) { // uses iterator()
+			elements.add(iter.NEXT());
+		}
+		HELPERS.assertContentsAnyOrder(elements, createSamplesArray());
+	}
+	
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testIterationOrdering() {
+#endignore
+		LIST KEY_GENERIC_TYPE elements = new ARRAY_LISTBRACES();
+		for (ITERATOR KEY_GENERIC_TYPE iter = collection.iterator();iter.hasNext();) { // uses iterator()
+			elements.add(iter.NEXT());
+		}
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(getOrderedElements());
+		assertEquals("Different ordered iteration", expected, elements);
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testIterator_removeAffectsBackingCollection() {
+#endignore
+		int originalSize = collection.size();
+		ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+		KEY_TYPE element = iterator.NEXT();
+		assertTrue(collection.contains(element)); // sanity check
+		iterator.remove();
+		assertFalse(collection.contains(element));
+		assertEquals(originalSize - 1, collection.size());
+	}
+
+#ignore
+	@CollectionFeature.Require({ KNOWN_ORDER, SUPPORTS_ITERATOR_REMOVE })
+	public void testIterator_knownOrderRemoveSupported() {
+#endignore
+		runIteratorTest(MODIFIABLE, ITERATOR_TESTER.KnownOrder.KNOWN_ORDER, getOrderedElements());
+	}
+
+#ignore
+	@CollectionFeature.Require(value = KNOWN_ORDER, absent = SUPPORTS_ITERATOR_REMOVE)
+	public void testIterator_knownOrderRemoveUnsupported() {
+#endignore
+		runIteratorTest(UNMODIFIABLE, ITERATOR_TESTER.KnownOrder.KNOWN_ORDER, getOrderedElements());
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = KNOWN_ORDER, value = SUPPORTS_ITERATOR_REMOVE)
+	public void testIterator_unknownOrderRemoveSupported() {
+#endignore
+		runIteratorTest(MODIFIABLE, ITERATOR_TESTER.KnownOrder.UNKNOWN_ORDER, getSampleElements());
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = { KNOWN_ORDER, SUPPORTS_ITERATOR_REMOVE })
+	public void testIterator_unknownOrderRemoveUnsupported() {
+#endignore
+		runIteratorTest(UNMODIFIABLE, ITERATOR_TESTER.KnownOrder.UNKNOWN_ORDER, getSampleElements());
+	}
+
+	private void runIteratorTest(Set<IteratorFeature> features, ITERATOR_TESTER.KnownOrder knownOrder, ITERABLE KEY_GENERIC_TYPE elements) {
+		if(knownOrder == ITERATOR_TESTER.KnownOrder.KNOWN_ORDER && !(collection instanceof LIST) && collection.iterator() instanceof LIST_ITERATOR) {
+			Set<IteratorFeature> listFeature = features.isEmpty() ? features : EnumSet.copyOf(features);
+#ignore
+			listFeature.retainAll(EnumSet.of(IteratorFeature.SUPPORTS_REMOVE));
+#endignore
+			new LIST_ITERATOR_TESTER KEY_GENERIC_TYPE(2, LISTS.singleton(INVALID_VALUE), Collections.unmodifiableSet(listFeature), elements, 0) {
+				@Override
+				protected LIST_ITERATOR KEY_GENERIC_TYPE newTargetIterator() {
+					resetCollection();
+					return (LIST_ITERATOR KEY_GENERIC_TYPE)collection.iterator();
+				}
+
+				@Override
+				protected void verify(LIST KEY_GENERIC_TYPE elements) {
+					expectContents(elements);
+				}
+			}.test();			
+		}
+		if(collection.iterator() instanceof BI_ITERATOR) {
+			new BIDIRECTIONAL_ITERATOR_TESTER KEY_GENERIC_TYPE(4, features, elements, knownOrder) {
+				@Override
+				protected BI_ITERATOR KEY_GENERIC_TYPE newTargetIterator() {
+					resetCollection();
+					return (BI_ITERATOR KEY_GENERIC_TYPE)collection.iterator();
+				}
+
+				@Override
+				protected void verify(LIST KEY_GENERIC_TYPE elements) {
+					expectContents(elements);
+				}
+			}.test();			
+			return;
+		}
+		new ITERATOR_TESTER KEY_GENERIC_TYPE(5, features, elements, knownOrder) {
+			@Override
+			protected ITERATOR KEY_GENERIC_TYPE newTargetIterator() {
+				resetCollection();
+				return collection.iterator();
+			}
+
+			@Override
+			protected void verify(LIST KEY_GENERIC_TYPE elements) {
+				expectContents(elements);
+			}
+		}.test();
+	}
+
+	public void testIteratorNoSuchElementException() {
+		ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+		while (iterator.hasNext()) {
+			iterator.NEXT();
+		}
+
+		try {
+			iterator.NEXT();
+			fail("iterator.next() should throw NoSuchElementException");
+		} catch (NoSuchElementException expected) {
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRemoveAllTester.template

@@ -0,0 +1,153 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionRemoveAllTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_emptyCollection() {
+		assertFalse("removeAll(emptyCollection) should return false", collection.removeAll(MINIMAL_COLLECTION.of()));
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_nonePresent() {
+		assertFalse("removeAll(disjointCollection) should return false", collection.removeAll(MINIMAL_COLLECTION.of(e3())));
+		expectUnchanged();
+	}
+	
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_nonePresentFetchRemoved() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		assertFalse("removeAll(disjointCollection) should return false", collection.removeAll(MINIMAL_COLLECTION.of(e3()), list::add));
+		expectUnchanged();
+		assertTrue(list.isEmpty());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_emptyCollectionFetching() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		assertFalse("removeAll(emptyCollection) should return false", collection.removeAll(MINIMAL_COLLECTION.of(), list::add));
+		expectUnchanged();
+		assertTrue(list.isEmpty());		
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAll_allPresent() {
+		assertTrue("removeAll(intersectingCollection) should return true", collection.removeAll(MINIMAL_COLLECTION.of(e0())));
+		expectMissing(e0());
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAll_somePresent() {
+		assertTrue("removeAll(intersectingCollection) should return true", collection.removeAll(MINIMAL_COLLECTION.of(e0(), e3())));
+		expectMissing(e0());
+	}
+
+#ignore
+	@CollectionFeature.Require({ SUPPORTS_REMOVE, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(SEVERAL)
+#endignore
+	public void testRemoveAllSomePresentConcurrentWithIteration() {
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			assertTrue(collection.removeAll(MINIMAL_COLLECTION.of(e0(), e3())));
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAll_somePresentLargeCollectionToRemove() {
+		assertTrue("removeAll(largeIntersectingCollection) should return true", collection.removeAll(MINIMAL_COLLECTION.of(e0(), e0(), e0(), e3(), e3(), e3())));
+		expectMissing(e0());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAll_someFetchRemovedElements() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		assertTrue("removeAll(largeIntersectingCollection, RemovedElements) should return true", collection.removeAll(MINIMAL_COLLECTION.of(e0(), e0(), e0(), e3(), e3(), e3()), list::add));
+		expectMissing(e0());
+		HELPERS.assertContentsAnyOrder(list, e0());
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_unsupportedEmptyCollection() {
+		try {
+			assertFalse("removeAll(emptyCollection) should return false or throw UnsupportedOperationException", collection.removeAll(MINIMAL_COLLECTION.of()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveAll_unsupportedNonePresent() {
+		try {
+			assertFalse("removeAll(disjointCollection) should return false or throw UnsupportedOperationException", collection.removeAll(MINIMAL_COLLECTION.of(e3())));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAll_unsupportedPresent() {
+		try {
+			collection.removeAll(MINIMAL_COLLECTION.of(e0()));
+			fail("removeAll(intersectingCollection) should throw UnsupportedOperationException");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		assertTrue(collection.contains(e0()));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRemoveIfTester.template

@@ -0,0 +1,119 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import java.util.ConcurrentModificationException;
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionRemoveIfTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+#endignore
+	public void testRemoveIf_alwaysFalse() {
+#if TYPE_OBJECT
+		assertFalse("remoIf(x -> false) should return false", collection.removeIf(x -> false));
+#else
+		assertFalse("remoIf(x -> false) should return false", collection.remIf(x -> false));
+#endif
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveIf_sometimesTrue() {
+		assertTrue("remIf(isEqual(present)) should return true",
+#if TYPE_OBJECT
+		collection.removeIf(T -> Objects.equals(T, e0())));
+#else
+		collection.remIf(T -> T == e0()));
+#endif
+		expectMissing(samples.e0());
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveIf_allPresent() {
+#if TYPE_OBJECT
+		assertTrue("remIf(x -> true) should return true", collection.removeIf(x -> true));
+#else
+		assertTrue("remIf(x -> true) should return true", collection.remIf(x -> true));
+#endif
+		expectContents();
+	}
+
+#ignore
+	@CollectionFeature.Require({ SUPPORTS_REMOVE, FAILS_FAST_ON_CONCURRENT_MODIFICATION })
+	@CollectionSize.Require(SEVERAL)
+#endignore
+	public void testRemoveIfSomeMatchesConcurrentWithIteration() {
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+#if TYPE_OBJECT
+			assertTrue(collection.removeIf(T -> Objects.equals(T, e0())));
+#else
+			assertTrue(collection.remIf(T -> T == e0()));
+#endif
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+#endignore
+	public void testRemoveIf_unsupportedEmptyCollection() {
+		try {
+			assertFalse("remIf(Predicate) should return false or throw UnsupportedOperationException",
+#if TYPE_OBJECT
+			collection.removeIf(x -> {throw new AssertionError("predicate should never be called");}));
+#else
+			collection.remIf(x -> {throw new AssertionError("predicate should never be called");}));
+#endif
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveIf_alwaysTrueUnsupported() {
+		try {
+#if TYPE_OBJECT
+			collection.removeIf(x -> true);
+#else
+			collection.remIf(x -> true);
+			fail("remIf(x -> true) should throw " + "UnsupportedOperationException");
+#endif
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		assertTrue(collection.contains(samples.e0()));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRetainAllTester.template

@@ -0,0 +1,337 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionRetainAllTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+
+	private class Target {
+		private final COLLECTION KEY_GENERIC_TYPE toRetain;
+		private final COLLECTION KEY_GENERIC_TYPE inverse = ARRAY_LIST.wrap(createSamplesArray());
+		private final String description;
+
+		private Target(COLLECTION KEY_GENERIC_TYPE toRetain, String description) {
+			this.toRetain = toRetain;
+			inverse.removeAll(toRetain);
+			this.description = description;
+		}
+
+		@Override
+		public String toString() {
+			return description;
+		}
+	}
+
+	private Target empty;
+	private Target disjoint;
+	private Target superset;
+	private Target nonEmptyProperSubset;
+	private Target sameElements;
+	private Target partialOverlap;
+	private Target containsDuplicates;
+
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+
+		empty = new Target(emptyCollection(), "empty");
+		disjoint = new Target(ARRAY_LIST.wrap(e3(), e4()), "disjoint");
+		superset = new Target(MINIMAL_COLLECTION.of(e0(), e1(), e2(), e3(), e4()), "superset");
+		nonEmptyProperSubset = new Target(MINIMAL_COLLECTION.of(e1()), "subset");
+		sameElements = new Target(ARRAY_LIST.wrap(createSamplesArray()), "sameElements");
+		containsDuplicates = new Target(MINIMAL_COLLECTION.of(e0(), e0(), e3(), e3()), "containsDuplicates");
+		partialOverlap = new Target(MINIMAL_COLLECTION.of(e2(), e3()), "partialOverlap");
+	}
+
+	// retainAll(empty)
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAll_emptyPreviouslyEmpty() {
+		expectReturnsFalse(empty);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAllExtra_emptyPreviouslyEmpty() {
+		expectReturnsFalseExtra(empty);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAll_emptyPreviouslyEmptyUnsupported() {
+		expectReturnsFalseOrThrows(empty);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRetainAll_emptyPreviouslyNonEmpty() {
+		expectReturnsTrue(empty);
+		expectContents();
+		expectMissing(e0(), e1(), e2());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRetainAllExtra_emptyPreviouslyNonEmpty() {
+		expectReturnsTrueExtra(empty);
+		expectContents();
+		expectMissing(e0(), e1(), e2());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRetainAll_emptyPreviouslyNonEmptyUnsupported() {
+		expectThrows(empty);
+		expectUnchanged();
+	}
+
+	// retainAll(disjoint)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAll_disjointPreviouslyEmpty() {
+		expectReturnsFalse(disjoint);
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAllExtra_disjointPreviouslyEmpty() {
+		expectReturnsFalseExtra(disjoint);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAll_disjointPreviouslyEmptyUnsupported() {
+		expectReturnsFalseOrThrows(disjoint);
+		expectUnchanged();
+	}
+#endignore
+#if !TYPE_BOOLEAN
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRetainAll_disjointPreviouslyNonEmpty() {
+		expectReturnsTrue(disjoint);
+		expectContents();
+		expectMissing(e0(), e1(), e2());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRetainAllExtra_disjointPreviouslyNonEmpty() {
+		expectReturnsTrueExtra(disjoint);
+		expectContents();
+		expectMissing(e0(), e1(), e2());
+	}
+
+#endif
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRetainAll_disjointPreviouslyNonEmptyUnsupported() {
+		expectThrows(disjoint);
+		expectUnchanged();
+	}
+
+	// retainAll(superset)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	public void testRetainAll_superset() {
+		expectReturnsFalse(superset);
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	public void testRetainAllExtra_superset() {
+		expectReturnsFalseExtra(superset);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	public void testRetainAll_supersetUnsupported() {
+		expectReturnsFalseOrThrows(superset);
+		expectUnchanged();
+	}
+
+	// retainAll(subset)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAll_subset() {
+		expectReturnsTrue(nonEmptyProperSubset);
+		expectContents(nonEmptyProperSubset.toRetain);
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAllExtra_subset() {
+		expectReturnsTrueExtra(nonEmptyProperSubset);
+		expectContents(nonEmptyProperSubset.toRetain);
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAll_subsetUnsupported() {
+		expectThrows(nonEmptyProperSubset);
+		expectUnchanged();
+	}
+
+	// retainAll(sameElements)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	public void testRetainAll_sameElements() {
+		expectReturnsFalse(sameElements);
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	public void testRetainAllExtra_sameElements() {
+		expectReturnsFalseExtra(sameElements);
+		expectUnchanged();
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	public void testRetainAll_sameElementsUnsupported() {
+		expectReturnsFalseOrThrows(sameElements);
+		expectUnchanged();
+	}
+
+	// retainAll(partialOverlap)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAll_partialOverlap() {
+		expectReturnsTrue(partialOverlap);
+		expectContents(e2());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAllExtra_partialOverlap() {
+		expectReturnsTrueExtra(partialOverlap);
+		expectContents(e2());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAll_partialOverlapUnsupported() {
+		expectThrows(partialOverlap);
+		expectUnchanged();
+	}
+
+	// retainAll(containsDuplicates)
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ONE)
+	public void testRetainAll_containsDuplicatesSizeOne() {
+		expectReturnsFalse(containsDuplicates);
+		expectContents(e0());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ONE)
+	public void testRetainAllExtra_containsDuplicatesSizeOne() {
+		expectReturnsFalseExtra(containsDuplicates);
+		expectContents(e0());
+	}
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAll_containsDuplicatesSizeSeveral() {
+		expectReturnsTrue(containsDuplicates);
+		expectContents(e0());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRetainAllExtra_containsDuplicatesSizeSeveral() {
+		expectReturnsTrueExtra(containsDuplicates);
+		expectContents(e0());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(ZERO)
+	public void testRetainAll_nullCollectionReferenceEmptySubject() {
+		try {
+			collection.retainAll(null);
+			// Returning successfully is not ideal, but tolerated.
+		} catch (NullPointerException tolerated) {
+		}
+	}
+
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRetainAll_nullCollectionReferenceNonEmptySubject() {
+		try {
+			collection.retainAll(null);
+			fail("retainAll(null) should throw NullPointerException");
+		} catch (NullPointerException expected) {
+		}
+	}
+	
+#endignore
+	private void expectReturnsTrue(Target target) {
+		String message = String.format("retainAll(%s) should return true", target);
+		assertTrue(message, collection.retainAll(target.toRetain));
+	}
+	
+	private void expectReturnsTrueExtra(Target target) {
+		String message = String.format("retainAll(%s, Removed) should return true", target);
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		assertTrue(message, collection.retainAll(target.toRetain, list::add));
+		HELPERS.assertEqualIgnoringOrder(target.inverse, list);
+	}
+
+	private void expectReturnsFalse(Target target) {
+		String message = String.format("retainAll(%s) should return false", target);
+		assertFalse(message, collection.retainAll(target.toRetain));
+	}
+	
+	private void expectReturnsFalseExtra(Target target) {
+		String message = String.format("retainAll(%s, Removed) should return false", target);
+		assertFalse(message, collection.retainAll(target.toRetain, T -> {}));
+	}
+
+	private void expectThrows(Target target) {
+		try {
+			collection.retainAll(target.toRetain);
+			fail(String.format("retainAll(%s) should throw", target));
+		} catch (UnsupportedOperationException expected) {
+		}
+	}
+
+	private void expectReturnsFalseOrThrows(Target target) {
+		String message = String.format("retainAll(%s) should return false or throw", target);
+		try {
+			assertFalse(message, collection.retainAll(target.toRetain));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionStreamTester.template

@@ -0,0 +1,59 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+#if !JDK_TYPE
+import speiger.src.collections.utils.SanityChecks;
+#endif
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionStreamTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(absent = KNOWN_ORDER)
+	public void testStreamToArrayUnknownOrder() {
+#endignore
+		synchronized (collection) {
+			HELPERS.assertContentsAnyOrder(getSampleElements(), unwrap(collection.primitiveStream().toArray()));
+		}
+	}
+
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testStreamToArrayKnownOrder() {
+#endignore
+		synchronized (collection) {
+			assertEquals(getOrderedElements(), ARRAY_LIST.wrap(unwrap(collection.primitiveStream().toArray())));
+		}
+	}
+
+	public void testStreamCount() {
+		synchronized (collection) {
+			assertEquals(getNumElements(), collection.primitiveStream().count());
+		}
+	}
+	
+#if JDK_TYPE
+	public KEY_TYPE[] unwrap(KEY_TYPE[] input) {
+		return input;
+	}
+#else
+	public KEY_TYPE[] unwrap(KEY_JAVA_TYPE[] input) {
+		KEY_TYPE[] other = NEW_KEY_ARRAY(input.length);
+		for(int i = 0,m=input.length;i<m;i++) {
+			other[i] = SanityChecks.SANITY_CAST(input[i]);
+		}
+		return other;
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionToArrayTester.template

@@ -0,0 +1,116 @@
+package speiger.src.testers.PACKAGE.tests.collection;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPECollectionToArrayTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testToArray_noArgs() {
+		KEY_OBJECT_TYPE[] array = collection.TO_ARRAY();
+		expectArrayContentsAnyOrder(createSamplesArray(), array);
+	}
+
+	public void testToArray_emptyArray() {
+		KEY_TYPE[] empty = emptyArray();
+		KEY_TYPE[] array = collection.TO_ARRAY(empty);
+		assertEquals("toLongArray(emptyT[]).length:", getNumElements(), array.length);
+		expectArrayContentsAnyOrder(createSamplesArray(), array);
+	}
+
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testToArray_emptyArray_ordered() {
+#endignore
+		KEY_TYPE[] empty = emptyArray();
+		KEY_TYPE[] array = collection.TO_ARRAY(empty);
+		assertEquals("toLongArray(emptyT[]).length:", getNumElements(), array.length);
+		expectArrayContentsInOrder(getOrderedElements(), array);
+	}
+
+	public void testToArray_emptyArrayOfObject() {
+		KEY_TYPE[] in = emptyArray();
+		KEY_TYPE[] array = collection.TO_ARRAY(in);
+		assertEquals("toLongArray(emptyObject[]).length", getNumElements(), array.length);
+		expectArrayContentsAnyOrder(createSamplesArray(), array);
+	}
+
+	public void testToArray_rightSizedArray() {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements());
+		assertSame("toLongArray(sameSizeE[]) should return the given array", array, collection.TO_ARRAY(array));
+		expectArrayContentsAnyOrder(createSamplesArray(), array);
+	}
+	
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testToArray_rightSizedArray_ordered() {
+#endignore
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements());
+		assertSame("toLongArray(sameSizeE[]) should return the given array", array, collection.TO_ARRAY(array));
+		expectArrayContentsInOrder(getOrderedElements(), array);
+	}
+
+	public void testToArray_rightSizedArrayOfObject() {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements());
+		assertSame("toLongArray(sameSizeObject[]) should return the given array", array, collection.TO_ARRAY(array));
+		expectArrayContentsAnyOrder(createSamplesArray(), array);
+	}
+
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testToArray_rightSizedArrayOfObject_ordered() {
+#endignore
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements());
+		assertSame("toLongArray(sameSizeObject[]) should return the given array", array, collection.TO_ARRAY(array));
+		expectArrayContentsInOrder(getOrderedElements(), array);
+	}
+
+	public void testToArray_oversizedArray() {
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements() + 2);
+		array[getNumElements()] = e3();
+		array[getNumElements() + 1] = e3();
+		assertSame("toLongArray(overSizedE[]) should return the given array", array, collection.TO_ARRAY(array));
+
+		LIST KEY_GENERIC_TYPE subArray = ARRAY_LIST.wrap(array).subList(0, getNumElements());
+		KEY_TYPE[] expectedSubArray = createSamplesArray();
+		for (int i = 0; i < getNumElements(); i++) {
+			assertTrue("toLongArray(overSizedE[]) should contain element " + expectedSubArray[i], subArray.contains(expectedSubArray[i]));
+		}
+		assertEquals("The array element immediately following the end of the collection should be nulled", EMPTY_KEY_VALUE, array[getNumElements()]);
+	}
+
+#ignore
+	@CollectionFeature.Require(KNOWN_ORDER)
+	public void testToArray_oversizedArray_ordered() {
+#endignore
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements() + 2);
+		array[getNumElements()] = e3();
+		array[getNumElements() + 1] = e3();
+		assertSame("toLongArray(overSizedE[]) should return the given array", array, collection.TO_ARRAY(array));
+
+		LIST KEY_GENERIC_TYPE expected = getOrderedElements();
+		for (int i = 0; i < getNumElements(); i++) {
+			assertEquals(expected.GET_KEY(i), array[i]);
+		}
+		assertEquals("The array element immediately following the end of the collection should be nulled", EMPTY_KEY_VALUE, array[getNumElements()]);
+	}
+
+	private void expectArrayContentsAnyOrder(KEY_OBJECT_TYPE[] expected, KEY_OBJECT_TYPE[] actual) {
+		HELPERS.assertEqualIgnoringOrder(ARRAY_LIST.wrap(expected), ARRAY_LIST.wrap(actual));
+	}
+
+	private void expectArrayContentsInOrder(LIST KEY_GENERIC_TYPE expected, KEY_TYPE[] actual) {
+		assertEquals("TO_ARRAY() ordered contents: ", expected, ARRAY_LIST.wrap(actual));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableCountTester.template

@@ -0,0 +1,47 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+
+#endif
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableCountTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableCount_null() {
+		try {
+			collection.count(null);
+			fail("This should throw a NullPointerException");
+		} catch (NullPointerException e) {
+		}
+	}
+	
+	public void testIterableCount_NoneFound() {
+		assertEquals("Expected none to be found", 0, collection.count(T -> false));
+	}
+	
+	public void testIterableCount_AllFound() {
+		assertEquals("Expected All to be found", getNumElements(), collection.count(T -> true));
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableCount_FindFirst() 
+	{
+		assertEquals("First element should be found", 1, collection.count(T -> KEY_EQUALS(T, e0())));		
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableCount_FindLast() {
+		assertEquals("Last element should be found", 1, collection.count(T -> KEY_EQUALS(T, e2())));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableDistinctTester.template

@@ -0,0 +1,24 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableDistinctTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testDistinct()
+	{
+		ArrayWithDuplicate KEY_GENERIC_TYPE duplicate = createArrayWithDuplicateElement();
+		resetContainer(primitiveGenerator.create(duplicate.elements));
+		LIST KEY_GENERIC_TYPE list = collection.distinct().pourAsList();
+		assertEquals("Distinct should remove duplicate elements", list.indexOf(duplicate.duplicate), list.lastIndexOf(duplicate.duplicate));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableFilterTester.template

@@ -0,0 +1,52 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+
+#endif
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.collections.PACKAGE.utils.SETS;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableFilterTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableFilter_missingElement() {
+		assertTrue(expectMissing(collection.filter(T -> KEY_EQUALS_NOT(T, e0())).pourAsSet(), e0()));
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableFilter_filterElement() {
+		assertFalse(expectMissing(SETS.singleton(e0()), collection.filter(T -> KEY_EQUALS(T, e0())).pourAsSet().TO_ARRAY()));		
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.ONE)
+#endignore
+	public void testIterableFilter_filterMissing() {
+		assertTrue(collection.filter(T -> KEY_EQUALS(T, e1())).pourAsList().isEmpty());
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableFilter_filterSeveral() {
+		assertTrue(expectMissing(SETS.singleton(e1()), collection.filter(T -> KEY_EQUALS_NOT(T, e1())).pourAsSet().TO_ARRAY()));
+	}
+	
+	protected boolean expectMissing(SET KEY_GENERIC_TYPE set, KEY_OBJECT_TYPE...elements)
+	{
+		for(KEY_OBJECT_TYPE element : elements)
+		{
+			if(set.contains(element)) return false;
+		}
+		return true;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableFindFirstTester.template

@@ -0,0 +1,43 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+
+#endif
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableFindFirstTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableFindFirst_null() {
+		try {
+			container.findFirst(null);
+			fail("This should throw a NullPointerException");
+		}
+		catch (NullPointerException e) {
+		}
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableFindFirst_FindFirstElements() {
+		assertEquals("First Element should be found", e0(), container.findFirst(T -> KEY_EQUALS(T, e0())));
+	}
+	
+	public void testIterableFindFirst_FindNothing() {
+		assertEquals("No element should be found", EMPTY_KEY_VALUE, container.findFirst(T -> KEY_EQUALS(T, e4())));
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableFindFirst_FindLastElement() {
+		assertEquals("Last Element should be found", e2(), container.findFirst(T -> KEY_EQUALS(T, e2())));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableLimitTester.template

@@ -0,0 +1,25 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableLimitTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableLimit() {
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES(collection);
+		list.REMOVE(list.size()-1);
+		LIST KEY_GENERIC_TYPE result = collection.limit(getNumElements()-1).pourAsList();
+		assertEquals(list.size(), result.size());
+		assertEquals("Limit does not retain the iteration order", list, result);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableMapTester.template

@@ -0,0 +1,132 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+
+#if TYPE_OBJECT
+import speiger.src.collections.chars.utils.CharArrays;
+#endif
+import speiger.src.collections.objects.lists.ObjectArrayList;
+import speiger.src.collections.objects.lists.ObjectList;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+#if !TYPE_OBJECT
+import speiger.src.testers.objects.utils.ObjectHelpers;
+#endif
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableMapTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableMap_ToString() {
+		assertEquals(HELPERS.copyToList(collection).toString(), collection.map(CLASS_OBJECT_TYPE::toString).pourAsList().toString());
+	}
+#if !TYPE_OBJECT
+
+#ignore
+	@CollectionFeature.Require(CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_Collection() {
+		ObjectList<Integer> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange((int)entry));
+		}
+		assertEquals(result, collection.flatMap(T -> ObjectArrayList.wrap(toRange((int)T))).pourAsList());
+	}
+	
+#ignore
+	@CollectionFeature.Require(CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_Array() {
+		ObjectList<Integer> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange((int)entry));
+		}
+		assertEquals(result, collection.arrayflatMap(T -> toRange((int)T)).pourAsList());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_CollectionUnordered() {
+		ObjectList<Integer> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange((int)entry));
+		}
+		ObjectHelpers.assertEqualIgnoringOrder(result, collection.flatMap(T -> ObjectArrayList.wrap(toRange((int)T))).pourAsList());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_ArrayUnordered() {
+		ObjectList<Integer> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange((int)entry));
+		}
+		ObjectHelpers.assertEqualIgnoringOrder(result, collection.arrayflatMap(T -> toRange((int)T)).pourAsList());
+	}
+	
+	private Integer[] toRange(int range) {
+		Integer[] result = new Integer[range];
+		for(int i = 0;i<range;i++) {
+			result[i] = Integer.valueOf(i);
+		}
+		return result;
+	}
+#else
+
+#ignore
+	@CollectionFeature.Require(CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_Collection() {
+		ObjectList<Character> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange(entry));
+		}
+		assertEquals(result, collection.flatMap(T -> ObjectArrayList.wrap(toRange(T))).pourAsList());
+	}
+
+#ignore
+	@CollectionFeature.Require(CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_Array() {
+		ObjectList<Character> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange(entry));
+		}
+		assertEquals(result, collection.arrayflatMap(this::toRange).pourAsList());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_CollectionUnordered() {
+		ObjectList<Character> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange(entry));
+		}
+		ObjectHelpers.assertEqualIgnoringOrder(result, collection.flatMap(T -> ObjectArrayList.wrap(toRange(T))).pourAsList());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+#endignore
+	public void testIterableMap_ArrayUnordered() {
+		ObjectList<Character> result = new ObjectArrayList<>();
+		for(KEY_TYPE entry : getOrderedElements()) {
+			result.addAll(toRange(entry));
+		}
+		ObjectHelpers.assertEqualIgnoringOrder(result, collection.arrayflatMap(this::toRange).pourAsList());
+	}
+
+	private Character[] toRange(T obj) {
+		return CharArrays.wrap(Objects.toString(obj).toCharArray());
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableMatchesTester.template

@@ -0,0 +1,107 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+
+#endif
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.sets.HASH_SET;
+import speiger.src.collections.PACKAGE.sets.SET;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableMatchesTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableMatch_AnyNull() {
+		try {
+			collection.matchesAny(null);
+			fail("MatchesAny should throw a NullPointException");
+		}
+		catch (NullPointerException e) {
+		}
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableMatch_AnyFoundFirstElement() {
+		assertTrue("Element ["+e0()+"] should be found", collection.matchesAny(T -> KEY_EQUALS(T, e0())));
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableMatch_AnyFoundLastElement() {
+		assertTrue("Element ["+e2()+"] should be found", collection.matchesAny(T -> KEY_EQUALS(T, e2())));
+	}
+	
+	public void testIterableMatch_AnyFoundNoElement() {
+		assertFalse("Element ["+e4()+"] should not be found", collection.matchesAny(T -> KEY_EQUALS(T, e4())));
+	}
+	
+	public void testIterableMatch_NoneNull() {
+		try {
+			collection.matchesNone(null);
+			fail("MatchesNone should throw a NullPointException");
+		}
+		catch (NullPointerException e) {
+		}
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableMatch_NoneFoundFirstElement() {
+		assertFalse("Element ["+e0()+"] should not be found", collection.matchesNone(T -> KEY_EQUALS(T, e0())));
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableMatch_NoneFoundLastElement() {
+		assertFalse("Element ["+e2()+"] should not be found", collection.matchesNone(T -> KEY_EQUALS(T, e2())));
+	}
+	
+	public void testIterableMatch_NoneFoundNoElement() {
+		assertTrue("Element ["+e4()+"] should not be found", collection.matchesNone(T -> KEY_EQUALS(T, e4())));
+	}
+	
+	public void testIterableMatch_AllNull() {
+		try {
+			collection.matchesAll(null);
+			fail("MatchesAny should throw a NullPointException");
+		}
+		catch (NullPointerException e) {
+		}
+	}
+	
+	public void testIterableMatch_AllFoundAllElements() {
+		SET KEY_GENERIC_TYPE set = new HASH_SETBRACES(collection);
+		assertTrue("All elements should be found", collection.matchesAll(set::contains));
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testIterableMatch_AllFoundNone() {
+		assertFalse("It should not find anything", collection.matchesAll(T -> false));
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.ZERO)
+#endignore
+	public void testIterableMatch_AllFoundNoneEmpty() {
+		assertTrue("Empty Collections should return true even if all have to be found", collection.matchesAll(T -> false));
+	}
+	
+#ignore
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testIterableMatches_AllPartical() {
+		assertFalse("Even if some elements were found, it should return false", collection.matchesAll(T -> KEY_EQUALS(T, e0())));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterablePeekTester.template

@@ -0,0 +1,19 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterablePeekTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterablePeek() {
+		LIST KEY_GENERIC_TYPE peeked = new ARRAY_LISTBRACES();
+		LIST KEY_GENERIC_TYPE result = new ARRAY_LISTBRACES();
+		collection.peek(peeked::add).forEach(result::add);
+		assertEquals("Collections should match since peek is just a preview of foreach", result, peeked);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableReduceTester.template

@@ -0,0 +1,78 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+#if TYPE_OBJECT
+import java.util.Objects;
+
+#endif
+import org.junit.Ignore;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableReduceTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{
+	public void testIterableReduce_Null() {
+		try {
+			collection.reduce(null);
+			fail("This should crash");
+		} catch (NullPointerException e) {
+		}
+	}
+	
+	public void testIterableReduce_extraNull() {
+		try {
+			collection.reduce(EMPTY_KEY_VALUE, null);
+			fail("This should crash");
+		} catch (NullPointerException e) {
+		}
+	}
+	
+	public void testIterableReduce() {
+		assertEquals("The sum of the collection should match", getSum(), collection.reduce(this::sum));
+	}
+	
+	public void testIterableExtraReduce() {
+#if TYPE_OBJECT
+		assertEquals("The sum of the collection should match", getObjectSum(), collection.reduce(new StringBuilder(), this::sum).toString());		
+#else
+		assertEquals("The sum of the collection should match", getSum(), collection.reduce(EMPTY_KEY_VALUE, this::sum));
+#endif
+	}
+	
+	public KEY_TYPE getSum()
+	{
+		KEY_TYPE result = EMPTY_KEY_VALUE;
+		for(KEY_TYPE key : collection)
+		{
+			result = sum(result, key);
+		}
+		return result;
+	}
+	
+	public KEY_TYPE sum(KEY_TYPE key, KEY_TYPE value)
+	{
+#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR
+		return (KEY_TYPE)(key + value);
+#else if TYPE_OBJECT
+		return value;
+#else
+		return key + value;
+#endif
+	}
+	
+#if TYPE_OBJECT
+	public StringBuilder sum(StringBuilder builder, T value) {
+		return builder.append(Objects.toString(value));
+	}
+	
+	public String getObjectSum() {
+		StringBuilder builder = new StringBuilder();
+		for(T key : collection)
+		{
+			builder = sum(builder, key);
+		}
+		return builder.toString();
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableSortedTester.template

@@ -0,0 +1,43 @@
+package speiger.src.testers.PACKAGE.tests.iterable;
+
+import org.junit.Ignore;
+
+#if TYPE_OBJECT
+import java.util.Comparator;
+import java.util.Map;
+#endif
+
+import com.google.common.collect.testing.features.CollectionFeature;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_COLLECTION_TESTER;
+import speiger.src.testers.utils.SpecialFeature;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEIterableSortedTester KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION_TESTER KEY_GENERIC_TYPE
+{	
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+	@SpecialFeature.Require(absent = SpecialFeature.MAP_ENTRY)
+#endignore
+	public void testIterableSorted() {
+		LIST KEY_GENERIC_TYPE expected = new ARRAY_LISTBRACES(collection);
+		expected.sort(null);
+		assertEquals("Elements were expected to be sorted", expected, collection.sorted(null).pourAsList());
+	}
+
+#if TYPE_OBJECT
+#ignore
+	@CollectionFeature.Require(absent = CollectionFeature.KNOWN_ORDER)
+	@SpecialFeature.Require(SpecialFeature.MAP_ENTRY)
+#endignore
+	public void testIterableSortedEntry() {
+		ObjectList<T> expected = new ObjectArrayList<>(collection);
+		Comparator<T> comparator = Comparator.comparing(T -> (Comparable<Object>)((Map.Entry<Object, Object>)T).getKey());
+		expected.sort(comparator);
+		assertEquals("Elements were expected to be sorted", expected, collection.sorted(comparator).pourAsList());
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAbsentTester.template

@@ -0,0 +1,60 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAbsentTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+#endignore
+	public void testIfAbsent() {
+		assertTrue("addIfAbsent(absent) should return true", getList().addIfAbsent(e1()));
+		expectAdded(e1());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+#endignore
+	public void testIfPresent() {
+		assertFalse("addIfAbsent(present) should return false", getList().addIfAbsent(e0()));
+		expectUnchanged();
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+#endignore
+	public void test_IfAbsentUnsupported() {
+		try {
+			assertFalse("addIfAbsent(absent) should return false", getList().addIfAbsent(e1()));			
+		} catch (UnsupportedOperationException e) {
+			//Success
+		}
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+#endignore
+	public void test_IfPresentUnsupported() {
+		try {
+			assertFalse("addIfAbsent(present) should return false", getList().addIfAbsent(e0()));			
+		} catch (UnsupportedOperationException e) {
+			//Success
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllArrayAtIndexTester.template

@@ -0,0 +1,194 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#if !TYPE_BOOLEAN
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+#endignore
+#endif
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_ADD_WITH_INDEX;
+#endignore
+
+#if !TYPE_BOOLEAN
+import com.google.common.collect.testing.features.CollectionFeature;
+#endif
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddAllArrayAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllArrayAtIndex_supportedAllPresent() {
+		getList().addElements(0, createArray(e0()));
+		expectAddedIndex(0, e0());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllArrayAtIndex_unsupportedAllPresent() {
+		try {
+			getList().addElements(0, createArray(e0()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllArrayAtIndex_supportedSomePresent() {
+		getList().addElements(0, createArray(e0(), e3()));
+		expectAddedIndex(0, e0(), e3());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllArrayAtIndex_unsupportedSomePresent() {
+		try {
+			getList().addElements(0, createArray(e0(), e3()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_supportedNothing() {
+		getList().addElements(0, emptyArray());
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_unsupportedNothing() {
+		try {
+			getList().addElements(0, emptyArray());
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_withDuplicates() {
+		getList().addElements(0, createArray(e0(), e1(), e0(), e1()));
+		expectAddedIndex(0, e0(), e1(), e0(), e1());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testAddAllArrayAtIndex_middle() {
+		getList().addElements(getNumElements() / 2, createDisjointArray());
+		expectAdded(getNumElements() / 2, createDisjointCollection());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllArrayAtIndex_end() {
+		getList().addElements(getNumElements(), createDisjointArray());
+		expectAdded(getNumElements(), createDisjointCollection());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_nullCollectionReference() {
+		try {
+#if TYPE_OBJECT
+			getList().addElements(0, (T[])null);
+#else
+			getList().addElements(0, null);
+#endif
+			fail("addElements(n, null) should throw");
+		} catch (NullPointerException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_negative() {
+		try {
+			getList().addElements(-1, createArray(e3()));
+			fail("addElements(-1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllArrayAtIndex_tooLarge() {
+		try {
+			getList().addElements(getNumElements() + 1, createArray(e3()));
+			fail("addElements(size + 1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+	
+#if !TYPE_BOOLEAN
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedToLargeOffset() {
+		try {
+			getList().addElements(0, createDisjointArray(), 5, 2);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedToSmallOffset() {
+		try {
+			getList().addElements(0, createDisjointArray(), -1, 2);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+		expectMissing(e3(), e4());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllArray_supportedAddSubArray() {
+		getList().addElements(0, createDisjointArray(), 0, 1);
+		expectAddedIndex(0, e3());
+		expectMissing(e4());
+	}
+#endif
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllAtIndexTester.template

@@ -0,0 +1,167 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_ADD_WITH_INDEX;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddAllAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllAtIndex_supportedAllPresent() {
+		assertTrue("addAll(n, allPresent) should return true", getList().addAll(0, MINIMAL_COLLECTION.of(e0())));
+		expectAddedIndex(0, e0());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllAtIndex_unsupportedAllPresent() {
+		try {
+			getList().addAll(0, MINIMAL_COLLECTION.of(e0()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllAtIndex_supportedSomePresent() {
+		assertTrue("addAll(n, allPresent) should return true", getList().addAll(0, MINIMAL_COLLECTION.of(e0(), e3())));
+		expectAddedIndex(0, e0(), e3());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllAtIndex_unsupportedSomePresent() {
+		try {
+			getList().addAll(0, MINIMAL_COLLECTION.of(e0(), e3()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_supportedNothing() {
+		assertFalse("addAll(n, nothing) should return false", getList().addAll(0, emptyCollection()));
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_unsupportedNothing() {
+		try {
+			assertFalse("addAll(n, nothing) should return false or throw", getList().addAll(0, emptyCollection()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_withDuplicates() {
+		MINIMAL_COLLECTION KEY_GENERIC_TYPE elementsToAdd = MINIMAL_COLLECTION.of(e0(), e1(), e0(), e1());
+		assertTrue("addAll(n, hasDuplicates) should return true", getList().addAll(0, elementsToAdd));
+		expectAddedIndex(0, e0(), e1(), e0(), e1());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testAddAllAtIndex_middle() {
+		assertTrue("addAll(middle, disjoint) should return true", getList().addAll(getNumElements() / 2, createDisjointCollection()));
+		expectAdded(getNumElements() / 2, createDisjointCollection());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllAtIndex_end() {
+		assertTrue("addAll(end, disjoint) should return true", getList().addAll(getNumElements(), createDisjointCollection()));
+		expectAdded(getNumElements(), createDisjointCollection());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_nullCollectionReference() {
+		try {
+			getList().addAll(0, (COLLECTION KEY_GENERIC_TYPE)null);
+			fail("addAll(n, null) should throw");
+		} catch (NullPointerException expected) {
+		}
+		expectUnchanged();
+	}
+	
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_nullListReference() {
+		try {
+			getList().addAll(0, (LIST KEY_GENERIC_TYPE)null);
+			fail("addAll(n, null) should throw");
+		} catch (NullPointerException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_negative() {
+		try {
+			getList().addAll(-1, MINIMAL_COLLECTION.of(e3()));
+			fail("addAll(-1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+#if !TYPE_BOOLEAN
+		expectMissing(e3());
+#endif
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllAtIndex_tooLarge() {
+		try {
+			getList().addAll(getNumElements() + 1, MINIMAL_COLLECTION.of(e3()));
+			fail("addAll(size + 1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+#if !TYPE_BOOLEAN
+		expectMissing(e3());
+#endif
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllListAtIndexTester.template

@@ -0,0 +1,155 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_ADD_WITH_INDEX;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddAllListAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListAtIndex_supportedAllPresent() {
+		assertTrue("addAll(n, allPresent) should return true", getList().addAll(0, ARRAY_LIST.wrap(e0())));
+		expectAddedIndex(0, e0());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListAtIndex_unsupportedAllPresent() {
+		try {
+			getList().addAll(0, ARRAY_LIST.wrap(e0()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListAtIndex_supportedSomePresent() {
+		assertTrue("addAll(n, allPresent) should return true", getList().addAll(0, ARRAY_LIST.wrap(e0(), e3())));
+		expectAddedIndex(0, e0(), e3());
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListAtIndex_unsupportedSomePresent() {
+		try {
+			getList().addAll(0, ARRAY_LIST.wrap(e0(), e3()));
+			fail("addAll(n, allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+#if !TYPE_BOOLEAN
+		expectMissing(e3());
+#endif
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_supportedNothing() {
+		assertFalse("addAll(n, nothing) should return false", getList().addAll(0, new ARRAY_LISTBRACES()));
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_unsupportedNothing() {
+		try {
+			assertFalse("addAll(n, nothing) should return false or throw", getList().addAll(0, new ARRAY_LISTBRACES()));
+		} catch (UnsupportedOperationException tolerated) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_withDuplicates() {
+		assertTrue("addAll(n, hasDuplicates) should return true", getList().addAll(0, ARRAY_LIST.wrap(e0(), e1(), e0(), e1())));
+		expectAddedIndex(0, e0(), e1(), e0(), e1());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testAddAllListAtIndex_middle() {
+		assertTrue("addAll(middle, disjoint) should return true", getList().addAll(getNumElements() / 2, new ARRAY_LISTBRACES(createDisjointCollection())));
+		expectAdded(getNumElements() / 2, createDisjointCollection());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListAtIndex_end() {
+		assertTrue("addAll(end, disjoint) should return true", getList().addAll(getNumElements(), new ARRAY_LISTBRACES(createDisjointCollection())));
+		expectAdded(getNumElements(), createDisjointCollection());
+	}
+	
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_nullListReference() {
+		try {
+			getList().addAll(0, (LIST KEY_GENERIC_TYPE)null);
+			fail("addAll(n, null) should throw");
+		} catch (NullPointerException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_negative() {
+		try {
+			getList().addAll(-1, ARRAY_LIST.wrap(e3()));
+			fail("addAll(-1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+#if !TYPE_BOOLEAN
+		expectMissing(e3());
+#endif
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAllListAtIndex_tooLarge() {
+		try {
+			getList().addAll(getNumElements() + 1, ARRAY_LIST.wrap(e3()));
+			fail("addAll(size + 1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+#if !TYPE_BOOLEAN
+		expectMissing(e3());
+#endif
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllTester.template

@@ -0,0 +1,115 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddAllTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAll_supportedAllPresent() {
+		assertTrue("addAll(allPresent) should return true", getList().addAll(MINIMAL_COLLECTION.of(e0())));
+		expectAdded(e0());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAll_unsupportedAllPresent() {
+		try {
+			getList().addAll(MINIMAL_COLLECTION.of(e0()));
+			fail("addAll(allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAll_withDuplicates() {
+		MINIMAL_COLLECTION KEY_GENERIC_TYPE elementsToAdd = MINIMAL_COLLECTION.of(e0(), e1(), e0(), e1());
+		assertTrue("addAll(hasDuplicates) should return true", getList().addAll(elementsToAdd));
+		expectAdded(e0(), e1(), e0(), e1());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListCollection_supportedAllPresent() {
+		assertTrue("addAll(allPresent) should return true", getList().addAll((COLLECTION KEY_GENERIC_TYPE)ARRAY_LIST.wrap(e0())));
+		expectAdded(e0());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllListCollection_unsupportedAllPresent() {
+		try {
+			getList().addAll((COLLECTION KEY_GENERIC_TYPE)ARRAY_LIST.wrap(e0()));
+			fail("addAll(allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllListCollection_withDuplicates() {
+		COLLECTION KEY_GENERIC_TYPE elementsToAdd = ARRAY_LIST.wrap(e0(), e1(), e0(), e1());
+		assertTrue("addAll(hasDuplicates) should return true", getList().addAll(elementsToAdd));
+		expectAdded(e0(), e1(), e0(), e1());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllList_supportedAllPresent() {
+		assertTrue("addAll(allPresent) should return true", getList().addAll(ARRAY_LIST.wrap(e0())));
+		expectAdded(e0());
+	}
+	
+#ignore
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testAddAllList_unsupportedAllPresent() {
+		try {
+			getList().addAll(ARRAY_LIST.wrap(e0()));
+			fail("addAll(allPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+#endignore
+	public void testAddAllList_withDuplicates() {
+		LIST KEY_GENERIC_TYPE elementsToAdd = ARRAY_LIST.wrap(e0(), e1(), e0(), e1());
+		assertTrue("addAll(hasDuplicates) should return true", getList().addAll(elementsToAdd));
+		expectAdded(e0(), e1(), e0(), e1());
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAtIndexTester.template

@@ -0,0 +1,112 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_ADD_WITH_INDEX;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAtIndex_supportedPresent() {
+		getList().add(0, e0());
+		expectAddedIndex(0, e0());
+	}
+
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAtIndex_unsupportedPresent() {
+		try {
+			getList().add(0, e0());
+			fail("add(n, present) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	public void testAddAtIndex_supportedNotPresent() {
+		getList().add(0, e3());
+		expectAddedIndex(0, e3());
+	}
+
+	@CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testAddAtIndexConcurrentWithIteration() {
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			getList().add(0, e3());
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
+	public void testAddAtIndex_unsupportedNotPresent() {
+		try {
+			getList().add(0, e3());
+			fail("add(n, notPresent) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testAddAtIndex_middle() {
+		getList().add(getNumElements() / 2, e3());
+		expectAddedIndex(getNumElements() / 2, e3());
+	}
+
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAddAtIndex_end() {
+		getList().add(getNumElements(), e3());
+		expectAddedIndex(getNumElements(), e3());
+	}
+	
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	public void testAddAtIndex_negative() {
+		try {
+			getList().add(-1, e3());
+			fail("add(-1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	public void testAddAtIndex_tooLarge() {
+		try {
+			getList().add(getNumElements() + 1, e3());
+			fail("add(size + 1, e) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+		expectMissing(e3());
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddTester.template

@@ -0,0 +1,37 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListAddTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAdd_supportedPresent() {
+		assertTrue("add(present) should return true", getList().add(e0()));
+		expectAdded(e0());
+	}
+
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(absent = ZERO)
+	public void testAdd_unsupportedPresent() {
+		try {
+			getList().add(e0());
+			fail("add(present) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListCreationTester.template

@@ -0,0 +1,30 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.REJECTS_DUPLICATES_AT_CREATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListCreationTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testCreateWithDuplicates() {
+		KEY_TYPE[] array = createSamplesArray();
+		array[1] = e0();
+		collection = primitiveGenerator.create(array);
+		expectContents(array);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListEqualsTester.template

@@ -0,0 +1,45 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_SET;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListEqualsTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+	public void testEquals_otherListWithSameElements() {
+		assertTrue("A List should equal any other List containing the same elements.", getList().equals(new ARRAY_LISTBRACES(getOrderedElements())));
+	}
+
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testEquals_otherListWithDifferentElements() {
+		ARRAY_LIST KEY_GENERIC_TYPE other = new ARRAY_LISTBRACES(getSampleElements());
+		other.set(other.size() / 2, e3());
+		assertFalse("A List should not equal another List containing different elements.", getList().equals(other));
+	}
+
+#ignore
+	@CollectionSize.Require(absent = CollectionSize.ZERO)
+#endignore
+	public void testEquals_shorterList() {
+		COLLECTION KEY_GENERIC_TYPE fewerElements = getSampleElements(getNumElements() - 1);
+		assertFalse("Lists of different sizes should not be equal.", getList().equals(new ARRAY_LISTBRACES(fewerElements)));
+	}
+
+	public void testEquals_longerList() {
+		COLLECTION KEY_GENERIC_TYPE moreElements = getSampleElements(getNumElements() + 1);
+		assertFalse("Lists of different sizes should not be equal.", getList().equals(new ARRAY_LISTBRACES(moreElements)));
+	}
+
+	public void testEquals_set() {
+		assertFalse("A List should never equal a Set.", getList().equals(MINIMAL_SET.of(getList())));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListExtractElementsTester.template

@@ -0,0 +1,86 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import org.junit.Ignore;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListExtractElementsTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+#endignore
+	public void testRemoveElements() {
+#if TYPE_OBJECT
+		assertArrayEquals("The Extracted Elements should be present", getSampleElements(1).TO_ARRAY(), getList().extractElements(0, 1, Object.class));
+#else
+		assertArrayEquals("The Extracted Elements should be present", getSampleElements(1).TO_ARRAY(), getList().extractElements(0, 1));
+#endif
+		expectMissing(e0());
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+#endignore
+	public void testRemove_FromToLow() {
+		try {
+#if TYPE_OBJECT
+			getList().extractElements(-1, 1, Object.class);
+#else
+			getList().extractElements(-1, 1);
+#endif
+			fail("extractElements(toLow, high) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+#endignore
+	public void testRemove_toToHigh() {
+		try {
+#if TYPE_OBJECT
+			getList().extractElements(0, getNumElements()+1, Object.class);
+#else
+			getList().extractElements(0, getNumElements()+1);
+#endif
+			fail("extractElements(low, toHigh) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+	
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+#endignore
+	public void testRemove_mixedUp() {
+		try {
+#if TYPE_OBJECT
+			getList().extractElements(1, 0, Object.class);
+#else
+			getList().extractElements(1, 0);
+#endif
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+	
+	private static void assertArrayEquals(String message, KEY_OBJECT_TYPE[] expected, KEY_OBJECT_TYPE[] actual) {
+		assertEquals(message, ARRAY_LIST.wrap(expected), ARRAY_LIST.wrap(actual));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListFillBufferTester.template

@@ -0,0 +1,23 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+import java.nio.JAVA_BUFFER;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListFillBufferTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+	public void testFillBuffer() {
+		JAVA_BUFFER buffer = JAVA_BUFFER.allocate(getNumElements());
+		getList().fillBuffer(buffer);
+		assertArrayEquals("Fill Buffer elements should equal", getSampleElements().TO_ARRAY(), buffer.array());
+	}
+
+	private static void assertArrayEquals(String message, KEY_TYPE[] expected, KEY_TYPE[] actual) {
+		assertEquals(message, ARRAY_LIST.wrap(expected), ARRAY_LIST.wrap(actual));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListGetElementsTester.template

@@ -0,0 +1,90 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListGetElementsTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionSize.Require(SEVERAL)
+#endignore
+	public void testGetElements_valid() {
+		KEY_OBJECT_TYPE[] samples = getSampleElements(2).TO_ARRAY();
+		assertArrayEquals("getElements(from, result) should match", samples, getList().getElements(0, NEW_KEY_ARRAY(2)));
+	}
+	
+#ignore
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testGetElements_validSmallerArray() {
+		KEY_OBJECT_TYPE[] samples = getSampleElements(2).TO_ARRAY();
+		samples[1] = EMPTY_KEY_VALUE;
+		assertArrayEquals("getElements(from, result) should match", samples, getList().getElements(0, NEW_KEY_ARRAY(2), 0, 1));
+	}
+	
+	public void testGetElements_outputToLarge() {
+		try {
+			getList().getElements(0, NEW_KEY_ARRAY(10));
+			fail("getElements(from, output) should have thrown a IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+		}
+	}
+	
+	public void testGetElements_offsetToSmall() {
+		try {
+			getList().getElements(0, NEW_KEY_ARRAY(2), -1, 2);
+			fail("getElements(from, output, offset, length) should have thrown a IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+			//success
+		}
+	}
+
+	public void testGetElements_offsetToLarge() {
+		try {
+			getList().getElements(0, NEW_KEY_ARRAY(2), 10, 2);
+			fail("getElements(from, output, offset, length) should have thrown a IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+			//success
+		}
+	}
+	
+	public void testGetElements_lengthExceedingArray() {
+		try {
+			getList().getElements(0, NEW_KEY_ARRAY(2), 0, 10);
+			fail("getElements(from, output, offset, length) should have thrown a IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+			//success
+		}
+	}
+	
+	public void testGet_negative() {
+		try {
+			getList().getElements(-1, NEW_KEY_ARRAY(2));
+			fail("getElements(-1) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+	
+	public void testGet_tooLarge() {
+		try {
+			getList().getElements(getNumElements(), NEW_KEY_ARRAY(2));
+			fail("get(size) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+	
+	private static void assertArrayEquals(String message, KEY_OBJECT_TYPE[] expected, KEY_OBJECT_TYPE[] actual) {
+		assertEquals(message, ARRAY_LIST.wrap(expected), ARRAY_LIST.wrap(actual));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListGetTester.template

@@ -0,0 +1,35 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListGetTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+	public void testGet_valid() {
+		expectContents(createOrderedArray());
+	}
+	
+	public void testGet_validList() {
+		expectContents(getOrderedElements());
+	}
+
+	public void testGet_negative() {
+		try {
+			getList().GET_KEY(-1);
+			fail("get(-1) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+
+	public void testGet_tooLarge() {
+		try {
+			getList().GET_KEY(getNumElements());
+			fail("get(size) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+	
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListIndexOfTester.template

@@ -0,0 +1,40 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.REJECTS_DUPLICATES_AT_CREATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_INDEX_OF_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListIndexOfTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_INDEX_OF_TESTER KEY_GENERIC_TYPE
+{
+	@Override
+	protected int find(KEY_TYPE o) {
+		return getList().indexOf(o);
+	}
+
+	@Override
+	protected String getMethodName() {
+		return "indexOf";
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testIndexOf_duplicate() {
+		KEY_TYPE[] array = createSamplesArray();
+		array[getNumElements() / 2] = e0();
+		collection = primitiveGenerator.create(array);
+		assertEquals("indexOf(duplicate) should return index of first occurrence", 0, getList().indexOf(e0()));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListLastIndexOfTester.template

@@ -0,0 +1,40 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.REJECTS_DUPLICATES_AT_CREATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_INDEX_OF_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListLastIndexOfTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_INDEX_OF_TESTER KEY_GENERIC_TYPE
+{
+	@Override
+	protected int find(KEY_TYPE o) {
+		return getList().lastIndexOf(o);
+	}
+
+	@Override
+	protected String getMethodName() {
+		return "lastIndexOf";
+	}
+
+#ignore
+	@CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testLastIndexOf_duplicate() {
+		KEY_TYPE[] array = createSamplesArray();
+		array[getNumElements() / 2] = e0();
+		collection = primitiveGenerator.create(array);
+		assertEquals("lastIndexOf(duplicate) should return index of last occurrence", getNumElements() / 2, getList().lastIndexOf(e0()));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListListIteratorTester.template

@@ -0,0 +1,73 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.IteratorFeature.MODIFIABLE;
+import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
+#endignore
+
+import java.util.Set;
+
+import com.google.common.collect.testing.IteratorFeature;
+
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.LIST_ITERATOR_TESTER;
+
+import speiger.src.testers.utils.SpecialFeature;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListListIteratorTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@SpecialFeature.Require(absent = SpecialFeature.ITERATOR_MODIFIABLE)
+	public void testListIterator_unmodifiable() {
+		runListIteratorTest(UNMODIFIABLE);
+	}
+	
+	@SpecialFeature.Require(SpecialFeature.ITERATOR_MODIFIABLE)
+	public void testListIterator_fullyModifiable() {
+		runListIteratorTest(MODIFIABLE);
+	}
+#endignore
+
+	private void runListIteratorTest(Set<IteratorFeature> features) {
+		new LIST_ITERATOR_TESTER KEY_GENERIC_TYPE(4, LISTS.singleton(e4()), features, HELPERS.copyToList(getOrderedElements()), 0) {
+			@Override
+			protected LIST_ITERATOR KEY_GENERIC_TYPE newTargetIterator() {
+				resetCollection();
+				return getList().listIterator();
+			}
+
+			@Override
+			protected void verify(LIST KEY_GENERIC_TYPE elements) {
+				expectContents(elements);
+			}
+		}.test();
+	}
+
+	public void testListIterator_tooLow() {
+		try {
+			getList().listIterator(-1);
+			fail();
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+
+	public void testListIterator_tooHigh() {
+		try {
+			getList().listIterator(getNumElements() + 1);
+			fail();
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+
+	public void testListIterator_atSize() {
+		getList().listIterator(getNumElements());
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListPresentTester.template

@@ -0,0 +1,54 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListPresentTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+	public void testIfAbsent() {
+		assertFalse("addIfPresent(absent) should return false", getList().addIfPresent(e1()));
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+	public void testIfPresent() {
+		assertTrue("addIfPresent(present) should return true", getList().addIfPresent(e0()));
+		expectAdded(e0());
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+	public void test_IfAbsentUnsupported() {
+		try {
+			assertFalse("addIfPresent(absent) should return false", getList().addIfPresent(e1()));			
+		} catch (UnsupportedOperationException e) {
+			//Success
+		}
+	}
+	
+	@CollectionFeature.Require(absent = SUPPORTS_ADD)
+	@CollectionSize.Require(ONE)
+	public void test_IfPresentUnsupported() {
+		try {
+			assertFalse("addIfPresent(present) should return false", getList().addIfPresent(e0()));			
+		} catch (UnsupportedOperationException e) {
+			//Success
+		}
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveAllTester.template

@@ -0,0 +1,32 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListRemoveAllTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testRemoveAll_duplicate() {
+		ArrayWithDuplicate KEY_GENERIC_TYPE arrayAndDuplicate = createArrayWithDuplicateElement();
+		collection = primitiveGenerator.create(arrayAndDuplicate.elements);
+		KEY_TYPE duplicate = arrayAndDuplicate.duplicate;
+		assertTrue("removeAll(intersectingCollection) should return true", getList().removeAll(MINIMAL_COLLECTION.of(duplicate)));
+		assertFalse("after removeAll(e), a collection should not contain e even if it initially contained e more than once.", getList().contains(duplicate));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveAtIndexTester.template

@@ -0,0 +1,106 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_REMOVE_WITH_INDEX;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListRemoveAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAtIndex_unsupported() {
+		try {
+			getList().REMOVE(0);
+			fail("remove(i) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+#endignore
+	public void testRemoveAtIndex_negative() {
+		try {
+			getList().REMOVE(-1);
+			fail("remove(-1) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+#endignore
+	public void testRemoveAtIndex_tooLarge() {
+		try {
+			getList().REMOVE(getNumElements());
+			fail("remove(size) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRemoveAtIndex_first() {
+		runRemoveTest(0);
+	}
+
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRemoveAtIndex_middle() {
+		runRemoveTest(getNumElements() / 2);
+	}
+
+	@CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAtIndexConcurrentWithIteration() {
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			getList().REMOVE(getNumElements() / 2);
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAtIndex_last() {
+		runRemoveTest(getNumElements() - 1);
+	}
+
+	private void runRemoveTest(int index) {
+		assertEquals(String.format("remove(%d) should return the element at index %d", index, index), getList().GET_KEY(index), getList().REMOVE(index));
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(createSamplesArray());
+		expected.REMOVE(index);
+		expectContents(expected);
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveElementsTester.template

@@ -0,0 +1,59 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListRemoveElementsTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+	public void testRemoveElements() {
+		getList().removeElements(0, 1);
+		expectMissing(e0());
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+	public void testRemove_FromToLow() {
+		try {
+			getList().removeElements(-1, 1);
+			fail("removeElements(toLow, high) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+	public void testRemove_toToHigh() {
+		try {
+			getList().removeElements(0, getNumElements()+1);
+			fail("removeElements(low, toHigh) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+	
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO})
+	public void testRemove_mixedUp() {
+		try {
+			getList().removeElements(1, 0);
+		} catch (IndexOutOfBoundsException e) {
+		}
+		expectUnchanged();
+	}
+#endignore
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveTester.template

@@ -0,0 +1,40 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListRemoveTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = {ZERO, ONE})
+#endignore
+	public void testRemove_duplicate() {
+		ArrayWithDuplicate KEY_GENERIC_TYPE arrayAndDuplicate = createArrayWithDuplicateElement();
+		collection = primitiveGenerator.create(arrayAndDuplicate.elements);
+		KEY_TYPE duplicate = arrayAndDuplicate.duplicate;
+
+		int firstIndex = getList().indexOf(duplicate);
+		int initialSize = getList().size();
+#if TYPE_OBJECT
+		assertTrue("remove(present) should return true", getList().remove(duplicate));
+#else
+		assertTrue("remove(present) should return true", getList().REMOVE_KEY(duplicate));
+#endif
+		assertTrue("After remove(duplicate), a list should still contain the duplicate element", getList().contains(duplicate));
+		assertFalse("remove(duplicate) should remove the first instance of the " + "duplicate element in the list", firstIndex == getList().indexOf(duplicate));
+		assertEquals("remove(present) should decrease the size of a list by one.", initialSize - 1, getList().size());
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListReplaceAllTester.template

@@ -0,0 +1,72 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_SET;
+#endignore
+
+import java.util.Arrays;
+#if TYPE_OBJECT
+import java.util.Objects;
+#endif
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListReplaceAllTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+#endignore
+	public void testReplaceAll() {
+#if TYPE_OBJECT
+		getList().replaceAll(e -> samples.e3());
+#else
+		getList().REPLACE(e -> samples.e3());
+#endif
+		KEY_TYPE[] array = NEW_KEY_ARRAY(getNumElements());
+		Arrays.fill(array, samples.e3());
+		expectContents(array);
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+#endignore
+	public void testReplaceAll_changesSome() {
+#if TYPE_OBJECT
+		getList().replaceAll(e -> Objects.equals(e, samples.e0()) ? samples.e3() : e);
+#else
+		getList().REPLACE(e -> e == samples.e0() ? samples.e3() : e);
+#endif
+		KEY_TYPE[] expected = createSamplesArray();
+		for (int i = 0; i < expected.length; i++) {
+			if (KEY_EQUALS(expected[i], samples.e0())) {
+				expected[i] = samples.e3();
+			}
+		}
+		expectContents(expected);
+	}
+
+#ignore
+	@CollectionSize.Require(absent = ZERO)
+	@ListFeature.Require(absent = SUPPORTS_SET)
+#endignore
+	public void testReplaceAll_unsupported() {
+		try {
+#if TYPE_OBJECT
+			getList().replaceAll(e -> e);
+#else
+			getList().REPLACE(e -> e);
+#endif
+			fail("replaceAll() should throw UnsupportedOperationException");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListRetainAllTester.template

@@ -0,0 +1,59 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+import speiger.src.testers.PACKAGE.utils.MINIMAL_COLLECTION;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListRetainAllTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testRetainAll_duplicatesKept() {
+		KEY_TYPE[] array = createSamplesArray();
+		array[1] = e0();
+		collection = primitiveGenerator.create(array);
+		assertFalse("containsDuplicates.retainAll(superset) should return false", collection.retainAll(MINIMAL_COLLECTION.of(createSamplesArray())));
+		expectContents(array);
+	}
+
+#ignore
+	@SuppressWarnings("unchecked")
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(SEVERAL)
+#endignore
+	public void testRetainAll_duplicatesRemoved() {
+		KEY_TYPE[] array = createSamplesArray();
+		array[1] = e0();
+		collection = primitiveGenerator.create(array);
+		assertTrue("containsDuplicates.retainAll(subset) should return true", collection.retainAll(MINIMAL_COLLECTION.of(e2())));
+		expectContents(e2());
+	}
+
+#ignore
+	@SuppressWarnings("unchecked")
+	@CollectionFeature.Require(SUPPORTS_REMOVE)
+	@CollectionSize.Require(SEVERAL)
+#endignore
+	public void testRetainAll_countIgnored() {
+		resetContainer(primitiveGenerator.create(createArray(e0(), e2(), e1(), e0())));
+		assertTrue(getList().retainAll(ARRAY_LIST.wrap(e0(), e1())));
+		HELPERS.assertContentsInOrder(getList(), e0(), e1(), e0());
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListSetTester.template

@@ -0,0 +1,83 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_SET;
+#endignore
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListSetTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testSet() {
+		doTestSet(e3());
+	}
+	
+	private void doTestSet(KEY_TYPE newValue) {
+		int index = aValidIndex();
+		KEY_TYPE initialValue = getList().GET_KEY(index);
+		assertEquals("set(i, x) should return the old element at position i.", initialValue, getList().set(index, newValue));
+		assertEquals("After set(i, x), get(i) should return x", newValue, getList().GET_KEY(index));
+		assertEquals("set() should not change the size of a list.", getNumElements(), getList().size());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	public void testSet_indexTooLow() {
+		try {
+			getList().set(-1, e3());
+			fail("set(-1) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@ListFeature.Require(SUPPORTS_SET)
+	public void testSet_indexTooHigh() {
+		int index = getNumElements();
+		try {
+			getList().set(index, e3());
+			fail("set(size) should throw IndexOutOfBoundsException");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@CollectionSize.Require(absent = ZERO)
+	@ListFeature.Require(absent = SUPPORTS_SET)
+	public void testSet_unsupported() {
+		try {
+			getList().set(aValidIndex(), e3());
+			fail("set() should throw UnsupportedOperationException");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@CollectionSize.Require(ZERO)
+	@ListFeature.Require(absent = SUPPORTS_SET)
+	public void testSet_unsupportedByEmptyList() {
+		try {
+			getList().set(0, e3());
+			fail("set() should throw UnsupportedOperationException or IndexOutOfBoundsException");
+		} catch (UnsupportedOperationException | IndexOutOfBoundsException tolerated) {
+		}
+		expectUnchanged();
+	}
+#endignore
+
+	private int aValidIndex() {
+		return getList().size() / 2;
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListSortTester.template

@@ -0,0 +1,102 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+#if TYPE_OBJECT
+import java.util.Comparator;
+#endif
+
+import org.junit.Ignore;
+
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.collections.utils.SanityChecks;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListSortTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(ListFeature.SUPPORTS_SET)
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testStableSort() {
+		KEY_TYPE[] keys = collection.TO_ARRAY(NEW_KEY_ARRAY(collection.size()));
+		SanityChecks.getRandom().setSeed(212121212L);
+		LISTS.shuffle(getList());
+		assertFalse(getList().equals(ARRAY_LIST.wrap(keys)));
+		getList().sort(null);
+		assertEquals(ARRAY_LIST.wrap(keys), getList());
+	}
+	
+#ignore
+	@ListFeature.Require(ListFeature.SUPPORTS_SET)
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testStableSort_Comparator() {
+		KEY_TYPE[] keys = collection.TO_ARRAY(NEW_KEY_ARRAY(collection.size()));
+		SanityChecks.getRandom().setSeed(212121212L);
+		LISTS.shuffle(getList());
+		assertFalse(getList().equals(ARRAY_LIST.wrap(keys)));
+#if TYPE_OBJECT
+		getList().sort((Comparator<T>)Comparator.naturalOrder());
+#else
+		getList().sort(CLASS_TYPE::compare);
+#endif
+		assertEquals(ARRAY_LIST.wrap(keys), getList());
+	}
+	
+#ignore
+	@ListFeature.Require(absent = ListFeature.SUPPORTS_SET)
+#endignore
+	public void testStableSort_Null() {
+		try {
+			getList().sort(null);
+		}
+		catch(UnsupportedOperationException e) {
+		}
+	}
+	
+#ignore
+	@ListFeature.Require(ListFeature.SUPPORTS_SET)
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testUnstableSort() {
+		KEY_TYPE[] keys = collection.TO_ARRAY(NEW_KEY_ARRAY(collection.size()));
+		SanityChecks.getRandom().setSeed(212121212L);
+		LISTS.shuffle(getList());
+		assertFalse(getList().equals(ARRAY_LIST.wrap(keys)));
+		getList().unstableSort(null);
+		assertEquals(ARRAY_LIST.wrap(keys), getList());		
+	}
+
+#ignore
+	@ListFeature.Require(ListFeature.SUPPORTS_SET)
+	@CollectionSize.Require(CollectionSize.SEVERAL)
+#endignore
+	public void testUnstableSort_Comparator() {
+		KEY_TYPE[] keys = collection.TO_ARRAY(NEW_KEY_ARRAY(collection.size()));
+		SanityChecks.getRandom().setSeed(212121212L);
+		LISTS.shuffle(getList());
+		assertFalse(getList().equals(ARRAY_LIST.wrap(keys)));
+#if TYPE_OBJECT
+		getList().unstableSort((Comparator<T>)Comparator.naturalOrder());
+#else
+		getList().unstableSort(CLASS_TYPE::compare);
+#endif
+		assertEquals(ARRAY_LIST.wrap(keys), getList());
+	}
+	
+#ignore
+	@ListFeature.Require(absent = ListFeature.SUPPORTS_SET)
+#endignore
+	public void testUnstableSort_Null() {
+		try {
+			getList().unstableSort(null);
+		}
+		catch(UnsupportedOperationException e) {
+		}
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListSubListTester.template

@@ -0,0 +1,309 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_ADD_WITH_INDEX;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_REMOVE_WITH_INDEX;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_SET;
+#endignore
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+import com.google.common.testing.SerializableTester;
+
+import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.collections.PACKAGE.utils.LISTS;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListSubListTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+	public void testSubList_startNegative() {
+		try {
+			getList().subList(-1, 0);
+			fail("subList(-1, 0) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+
+	public void testSubList_endTooLarge() {
+		try {
+			getList().subList(0, getNumElements() + 1);
+			fail("subList(0, size + 1) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+	}
+
+	public void testSubList_startGreaterThanEnd() {
+		try {
+			getList().subList(1, 0);
+			fail("subList(1, 0) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		} catch (IllegalArgumentException expected) {
+		}
+	}
+
+	public void testSubList_empty() {
+		assertEquals("subList(0, 0) should be empty", LISTS.empty(), getList().subList(0, 0));
+	}
+
+	public void testSubList_entireList() {
+		assertEquals("subList(0, size) should be equal to the original list", getList(), getList().subList(0, getNumElements()));
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testSubList_subListRemoveAffectsOriginal() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 1);
+		subList.REMOVE(0);
+		expectContents(ARRAY_LIST.wrap(createSamplesArray()).subList(1, getNumElements()));
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testSubList_subListClearAffectsOriginal() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 1);
+		subList.clear();
+		expectContents(ARRAY_LIST.wrap(createSamplesArray()).subList(1, getNumElements()));
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+#endignore
+	public void testSubList_subListAddAffectsOriginal() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 0);
+		subList.add(e3());
+		expectAddedIndex(0, e3());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testSubList_subListSetAffectsOriginal() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 1);
+		subList.set(0, e3());
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(createSamplesArray());
+		expected.set(0, e3());
+		expectContents(expected);
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testSubList_originalListSetAffectsSubList() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 1);
+		getList().set(0, e3());
+		assertEquals("A set() call to a list after a sublist has been created should be reflected in the sublist", LISTS.singleton(e3()), subList);
+	}
+	
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_subListRemoveAffectsOriginalLargeList() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(1, 3);
+#if TYPE_OBJECT
+		subList.remove(e2());
+#else
+		subList.REMOVE_KEY(e2());
+#endif
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(createSamplesArray());
+		expected.REMOVE(2);
+		expectContents(expected);
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_subListAddAtIndexAffectsOriginalLargeList() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(2, 3);
+		subList.add(0, e3());
+		expectAddedIndex(2, e3());
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_subListSetAffectsOriginalLargeList() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(1, 2);
+		subList.set(0, e3());
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(createSamplesArray());
+		expected.set(1, e3());
+		expectContents(expected);
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_SET)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_originalListSetAffectsSubListLargeList() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(1, 3);
+		getList().set(1, e3());
+		assertEquals("A set() call to a list after a sublist has been created " + "should be reflected in the sublist",
+				Arrays.asList(e3(), e2()), subList);
+	}
+
+	public void testSubList_ofSubListEmpty() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 0).subList(0, 0);
+		assertEquals("subList(0, 0).subList(0, 0) should be an empty list", LISTS.empty(), subList);
+	}
+
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testSubList_ofSubListNonEmpty() {
+		LIST KEY_GENERIC_TYPE subList = getList().subList(0, 2).subList(1, 2);
+		assertEquals("subList(0, 2).subList(1, 2) " + "should be a single-element list of the element at index 1",
+				Collections.singletonList(getOrderedElements().GET_KEY(1)), subList);
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO })
+#endignore
+	public void testSubList_size() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = getNumElements();
+		assertEquals(size, list.subList(0, size).size());
+		assertEquals(size - 1, list.subList(0, size - 1).size());
+		assertEquals(size - 1, list.subList(1, size).size());
+		assertEquals(0, list.subList(size, size).size());
+		assertEquals(0, list.subList(0, 0).size());
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO })
+#endignore
+	public void testSubList_isEmpty() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = getNumElements();
+		for (LIST KEY_GENERIC_TYPE subList : Arrays.asList(list.subList(0, size), list.subList(0, size - 1), list.subList(1, size),
+				list.subList(0, 0), list.subList(size, size))) {
+			assertEquals(subList.size() == 0, subList.isEmpty());
+		}
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_get() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = getNumElements();
+		LIST KEY_GENERIC_TYPE copy = list.subList(0, size);
+		LIST KEY_GENERIC_TYPE head = list.subList(0, size - 1);
+		LIST KEY_GENERIC_TYPE tail = list.subList(1, size);
+		assertEquals(list.GET_KEY(0), copy.GET_KEY(0));
+		assertEquals(list.GET_KEY(size - 1), copy.GET_KEY(size - 1));
+		assertEquals(list.GET_KEY(1), tail.GET_KEY(0));
+		assertEquals(list.GET_KEY(size - 1), tail.GET_KEY(size - 2));
+		assertEquals(list.GET_KEY(0), head.GET_KEY(0));
+		assertEquals(list.GET_KEY(size - 2), head.GET_KEY(size - 2));
+		for (LIST KEY_GENERIC_TYPE subList : Arrays.asList(copy, head, tail)) {
+			for (int index : Arrays.asList(-1, subList.size())) {
+				try {
+					subList.GET_KEY(index);
+					fail("expected IndexOutOfBoundsException");
+				} catch (IndexOutOfBoundsException expected) {
+				}
+			}
+		}
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_contains() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = getNumElements();
+		LIST KEY_GENERIC_TYPE copy = list.subList(0, size);
+		LIST KEY_GENERIC_TYPE head = list.subList(0, size - 1);
+		LIST KEY_GENERIC_TYPE tail = list.subList(1, size);
+		assertTrue(copy.contains(list.GET_KEY(0)));
+		assertTrue(head.contains(list.GET_KEY(0)));
+		assertTrue(tail.contains(list.GET_KEY(1)));
+		// The following assumes all elements are distinct.
+		assertTrue(copy.contains(list.GET_KEY(size - 1)));
+		assertTrue(head.contains(list.GET_KEY(size - 2)));
+		assertTrue(tail.contains(list.GET_KEY(size - 1)));
+		assertFalse(head.contains(list.GET_KEY(size - 1)));
+		assertFalse(tail.contains(list.GET_KEY(0)));
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_indexOf() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = getNumElements();
+		LIST KEY_GENERIC_TYPE copy = list.subList(0, size);
+		LIST KEY_GENERIC_TYPE head = list.subList(0, size - 1);
+		LIST KEY_GENERIC_TYPE tail = list.subList(1, size);
+		assertEquals(0, copy.indexOf(list.GET_KEY(0)));
+		assertEquals(0, head.indexOf(list.GET_KEY(0)));
+		assertEquals(0, tail.indexOf(list.GET_KEY(1)));
+		// The following assumes all elements are distinct.
+		assertEquals(size - 1, copy.indexOf(list.GET_KEY(size - 1)));
+		assertEquals(size - 2, head.indexOf(list.GET_KEY(size - 2)));
+		assertEquals(size - 2, tail.indexOf(list.GET_KEY(size - 1)));
+		assertEquals(-1, head.indexOf(list.GET_KEY(size - 1)));
+		assertEquals(-1, tail.indexOf(list.GET_KEY(0)));
+	}
+
+#ignore
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testSubList_lastIndexOf() {
+		LIST KEY_GENERIC_TYPE list = getList();
+		int size = list.size();
+		LIST KEY_GENERIC_TYPE copy = list.subList(0, size);
+		LIST KEY_GENERIC_TYPE head = list.subList(0, size - 1);
+		LIST KEY_GENERIC_TYPE tail = list.subList(1, size);
+		assertEquals(size - 1, copy.lastIndexOf(list.GET_KEY(size - 1)));
+		assertEquals(size - 2, head.lastIndexOf(list.GET_KEY(size - 2)));
+		assertEquals(size - 2, tail.lastIndexOf(list.GET_KEY(size - 1)));
+		// The following assumes all elements are distinct.
+		assertEquals(0, copy.lastIndexOf(list.GET_KEY(0)));
+		assertEquals(0, head.lastIndexOf(list.GET_KEY(0)));
+		assertEquals(0, tail.lastIndexOf(list.GET_KEY(1)));
+		assertEquals(-1, head.lastIndexOf(list.GET_KEY(size - 1)));
+		assertEquals(-1, tail.lastIndexOf(list.GET_KEY(0)));
+	}
+
+#ignore
+	@CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS)
+#endignore
+	public void testReserializeWholeSubList() {
+		SerializableTester.reserializeAndAssert(getList().subList(0, getNumElements()));
+	}
+
+#ignore
+	@CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS)
+#endignore
+	public void testReserializeEmptySubList() {
+		SerializableTester.reserializeAndAssert(getList().subList(0, 0));
+	}
+
+#ignore
+	@CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testReserializeSubList() {
+		SerializableTester.reserializeAndAssert(getList().subList(0, 2));
+	}
+}

src/builder/resources/speiger/assets/testers/templates/tests/list/ListSwapRemoveAtIndexTester.template

@@ -0,0 +1,115 @@
+package speiger.src.testers.PACKAGE.tests.list;
+
+import org.junit.Ignore;
+
+#ignore
+import static com.google.common.collect.testing.features.CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
+import static com.google.common.collect.testing.features.CollectionSize.ONE;
+import static com.google.common.collect.testing.features.CollectionSize.ZERO;
+import static com.google.common.collect.testing.features.ListFeature.SUPPORTS_REMOVE_WITH_INDEX;
+#endignore
+
+import java.util.ConcurrentModificationException;
+
+import com.google.common.collect.testing.features.CollectionFeature;
+import com.google.common.collect.testing.features.CollectionSize;
+import com.google.common.collect.testing.features.ListFeature;
+
+import speiger.src.collections.PACKAGE.collections.ITERATOR;
+import speiger.src.collections.PACKAGE.collections.COLLECTION;
+import speiger.src.collections.PACKAGE.lists.LIST;
+import speiger.src.testers.PACKAGE.tests.base.ABSTRACT_LIST_TESTER;
+import speiger.src.testers.PACKAGE.utils.HELPERS;
+
+@Ignore
+@SuppressWarnings("javadoc")
+public class FILE_KEY_TYPEListSwapRemoveAtIndexTester KEY_GENERIC_TYPE extends ABSTRACT_LIST_TESTER KEY_GENERIC_TYPE
+{
+#ignore
+	@ListFeature.Require(absent = SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRemoveAtIndex_unsupported() {
+		try {
+			getList().swapRemove(0);
+			fail("remove(i) should throw");
+		} catch (UnsupportedOperationException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	public void testRemoveAtIndex_negative() {
+		try {
+			getList().swapRemove(-1);
+			fail("remove(-1) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	public void testRemoveAtIndex_tooLarge() {
+		try {
+			getList().swapRemove(getNumElements());
+			fail("remove(size) should throw");
+		} catch (IndexOutOfBoundsException expected) {
+		}
+		expectUnchanged();
+	}
+
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+	public void testRemoveAtIndex_first() {
+		runRemoveTest(0);
+	}
+	
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+#endignore
+	public void testRemoveAtSecondOfFour() {
+		COLLECTION KEY_GENERIC_TYPE samples = getSampleElements(4);
+		KEY_TYPE[] data = samples.TO_ARRAY(NEW_KEY_ARRAY(4));
+		collection = primitiveGenerator.create(data);
+		assertEquals(data[1], getList().GET_KEY(1));
+		assertEquals(data[1], getList().swapRemove(1));
+		assertEquals(data[3], getList().GET_KEY(1));
+	}
+	
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = { ZERO, ONE })
+	public void testRemoveAtIndex_middle() {
+		runRemoveTest(getNumElements() / 2);
+	}
+
+	@CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAtIndexConcurrentWithIteration() {
+		try {
+			ITERATOR KEY_GENERIC_TYPE iterator = collection.iterator();
+			getList().swapRemove(getNumElements() / 2);
+			iterator.NEXT();
+			fail("Expected ConcurrentModificationException");
+		} catch (ConcurrentModificationException expected) {
+			// success
+		}
+	}
+
+#ignore
+	@ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
+	@CollectionSize.Require(absent = ZERO)
+#endignore
+	public void testRemoveAtIndex_last() {
+		runRemoveTest(getNumElements() - 1);
+	}
+
+	private void runRemoveTest(int index) {
+		assertEquals(String.format("remove(%d) should return the element at index %d", index, index), getList().GET_KEY(index), getList().swapRemove(index));
+		LIST KEY_GENERIC_TYPE expected = HELPERS.copyToList(createSamplesArray());
+		expected.set(index, expected.GET_KEY(expected.size()-1));
+		expected.REMOVE(expected.size()-1);
+		expectContents(expected);
+	}
+}