Implemented Module Configuration

That this works is crazy...

.github/workflows/build_action.yml

@@ -0,0 +1,32 @@
+name: Latest Build
+
+on:
+   push:
+      branches: [ master ]
+   pull_request:
+      branches: [ master ]
+
+jobs:
+   build:
+      strategy:
+         fail-fast: false
+         matrix:
+            jdk: [8, 11, 14, 16, 17, 18]
+
+      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/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
+         run: |
+           ./gradlew generateTestSource test jacocoTestReport --info -Dfull_test_suite=true
+           ./gradlew --stop
+         
+      -  name: Publish Test Result
+         uses: EnricoMi/publish-unit-test-result-action@v2
+         id: test-results
+         if: always()
+         with:
+            junit_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@v2
+         id: test-results
+         if: always()
+         with:
+            junit_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

Changelog.md

@@ -1,5 +1,11 @@
 # Changelog of versions
 
+### Version 0.7.1 (Unreleased)
+- Added: ISizeProvider interface (Optimization Helper)
+- Added: ISizeProvider into most Iterable implementations (Distinct/Filter/FlatMap/ArrayFlatMap don't support it, for obvious reasons)
+- Added: ToArray function into Iterable which uses ISizeProvider to reduce overhead of duplicating arrays.
+- Fixed: putIfAbsent now replaces defaultValues
+
 ### Version 0.7.0
 - Added: Over 11 Million Unit Tests to this library to ensure quality.
 - Added: ArrayList size constructor now throws IllegalStateException if the size parameter is negative

README.md

@@ -1,8 +1,11 @@
-![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_validator.yml/badge.svg)
+![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_action.yml/badge.svg)
 [![Latest Release](https://jitpack.io/v/Speiger/Primitive-Collections.svg)](https://jitpack.io/#Speiger/Primitive-Collections)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-![GitHub commit activity](https://img.shields.io/github/commit-activity/m/Speiger/Primitive-Collections)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/m/Speiger/Primitive-Collections)      
+![Unit Tests](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_tests_action.yml/badge.svg)
+![Coverage](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/405abd1d2f6c19ac70f20b8b1772176f42d5c5d3/jacoco.svg)
 [![codecov](https://codecov.io/gh/Speiger/Primitive-Collections/branch/debug/graph/badge.svg?token=WSTSNJM0EN)](https://codecov.io/gh/Speiger/Primitive-Collections)
+![Tests Done](https://gist.githubusercontent.com/Speiger/280257cd19cbe1dda3789bebd4ff65cf/raw/405abd1d2f6c19ac70f20b8b1772176f42d5c5d3/tests.svg)
 # Primitive-Collections
 This is a Simple Primitive Collections Library aimed to outperform Java's Collection Library and FastUtil.  
 Both in Performance and Quality of Life Features.  

build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java-library'
+    id "jacoco"
 }
 
 tasks.withType(JavaCompile) {
@@ -44,6 +45,7 @@ configurations {
 }
 
 dependencies {
+	builderImplementation 'com.google.code.gson:gson:2.10'
 	builderImplementation 'de.speiger:Simple-Code-Generator:1.1.4'
     testImplementation 'junit:junit:4.12'
     testImplementation 'com.google.guava:guava-testlib:31.0.1-jre'
@@ -62,7 +64,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 +72,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', 'silent']
 }
 
 task javadocJar(type: Jar) {
@@ -94,8 +104,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"),
+	BOOLEAN("boolean", "Boolean", "Boolean", "booleans", "BOOLEAN", "false", "false"),
-	BYTE("byte", "Byte", "Byte", "bytes", "BYTE", "(byte)0"),
+	BYTE("byte", "Byte", "Byte", "bytes", "BYTE", "(byte)0", "(byte)-1"),
-	SHORT("short", "Short", "Short", "shorts", "SHORT", "(short)0"),
+	SHORT("short", "Short", "Short", "shorts", "SHORT", "(short)0", "(short)-1"),
-	CHAR("char", "Character", "Char", "chars", "CHAR", "(char)0"),
+	CHAR("char", "Character", "Char", "chars", "CHAR", "(char)0", "(char)-1"),
-	INT("int", "Integer", "Int", "ints", "INT", "0"),
+	INT("int", "Integer", "Int", "ints", "INT", "0", "-1"),
-	LONG("long", "Long", "Long", "longs", "LONG", "0L"),
+	LONG("long", "Long", "Long", "longs", "LONG", "0L", "-1L"),
-	FLOAT("float", "Float", "Float", "floats", "FLOAT", "0F"),
+	FLOAT("float", "Float", "Float", "floats", "FLOAT", "0F", "-1F"),
-	DOUBLE("double", "Double", "Double", "doubles", "DOUBLE", "0D"),
+	DOUBLE("double", "Double", "Double", "doubles", "DOUBLE", "0D", "-1D"),
-	OBJECT("T", "T", "Object", "objects", "OBJECT", "null");
+	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()
@@ -50,6 +52,11 @@ public enum ClassType
 		return classType;
 	}
 	
+	public String getClassPath()
+	{
+		return this == OBJECT ? "Object" : classType;
+	}
+	
 	public String getClassType(boolean value) 
 	{
 		return value && this == OBJECT ? "V" : classType;
@@ -90,6 +97,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

@@ -1,452 +0,0 @@
-package speiger.src.builder;
-
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.function.UnaryOperator;
-
-import speiger.src.builder.mappers.ArgumentMapper;
-import speiger.src.builder.mappers.IMapper;
-import speiger.src.builder.mappers.InjectMapper;
-import speiger.src.builder.mappers.LineMapper;
-import speiger.src.builder.mappers.SimpleMapper;
-import speiger.src.builder.processor.TemplateProcess;
-
-@SuppressWarnings("javadoc")
-public class GlobalVariables
-{
-	List<IMapper> operators = new ArrayList<>();
-	Set<String> flags = new LinkedHashSet<>();
-	ClassType type;
-	ClassType valueType;
-	
-	public GlobalVariables(ClassType type, ClassType subType)
-	{
-		this.type = type;
-		valueType = subType;
-	}
-	
-	public GlobalVariables createVariables()
-	{
-		addSimpleMapper("VALUE_PACKAGE", valueType.getPathType());
-		addSimpleMapper("PACKAGE", type.getPathType());
-		addSimpleMapper("CLASS_TYPE", type.getClassType());
-		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
-		addSimpleMapper("KEY_TYPE", type.getKeyType());
-		addSimpleMapper("KEY_SPECIAL_TYPE", type.isObject() ? "E" : type.getKeyType());
-		addSimpleMapper("VALUE_TYPE", valueType.getValueType());
-		addSimpleMapper("VALUE_SPECIAL_TYPE", valueType.isObject() ? "E" : valueType.getKeyType());
-		
-		addSimpleMapper("EMPTY_KEY_VALUE", type.getEmptyValue());
-		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
-		
-		addSimpleMapper(" KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+">" : "");
-		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+", "+type.getKeyType()+">" : "");
-		
-		addSimpleMapper(" VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+">" : "");
-		addSimpleMapper(" VALUE_VALUE_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : "");
-		
-		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()+">" : ""));
-		
-		addSimpleMapper(" NO_GENERIC_TYPE", type.isObject() ? "<?>" : "");
-		addSimpleMapper(" NO_KV_GENERIC_TYPE", type.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
-		addSimpleMapper(" KEY_COMPAREABLE_TYPE", type.isObject() ? "<"+type.getKeyType()+" extends Comparable<T>>" : "");
-		
-		addSimpleMapper(" KEY_SUPER_GENERIC_TYPE", type.isObject() ? "<? super "+type.getKeyType()+">" : "");
-		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_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()+">>" : ""));
-		
-		addInjectMapper(" KEY_SPECIAL_GENERIC_TYPE", type.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" VALUE_SPECIAL_GENERIC_TYPE", valueType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" KSK_GENERIC_TYPE", type.isObject() ? "<%s, "+type.getKeyType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" KKS_GENERIC_TYPE", type.isObject() ? "<"+type.getKeyType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addArgumentMapper(" KSS_GENERIC_TYPE", type.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
-		addInjectMapper(" VSV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "<%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" VVS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
-		addArgumentMapper(" VSS_GENERIC_TYPE", valueType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
-
-		addSimpleMapper(" GENERIC_KEY_BRACES", type.isObject() ? " <"+type.getKeyType()+">" : "");
-		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
-		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", type.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
-		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", type.isObject() ? (valueType.isObject() ? " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">, "+valueType.getValueType()+">" : " <"+type.getKeyType()+" extends Enum<"+type.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
-		
-		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", type.isObject() ? " <"+type.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
-		
-		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("BRACES", type.isObject() ? "<>" : "");
-		if(type.needsCustomJDKType())
-		{
-			addSimpleMapper("JAVA_TYPE", type.getCustomJDKType().getKeyType());
-			addSimpleMapper("SANITY_CAST", "castTo"+type.getFileType());
-		}
-		addSimpleMapper("JAVA_CLASS", type.getCustomJDKType().getClassType());
-		if(valueType.needsCustomJDKType())
-		{
-			addSimpleMapper("SANITY_CAST_VALUE", "castTo"+valueType.getFileType());
-		}
-		addComment("@ArrayType", "@param <%s> the type of array that the operation should be applied");
-		addComment("@Type", "@param <%s> the type of elements maintained by this Collection");
-		addValueComment("@ValueArrayType", "@param <%s> the type of array that the operation should be applied");
-		addValueComment("@ValueType", "@param <%s> the type of elements maintained by this Collection");
-		addAnnontion("@PrimitiveOverride", "@Override");
-		addSimpleMapper("@PrimitiveDoc", "");
-		addAnnontion("@Primitive", "@Deprecated");
-		addValueAnnontion("@ValuePrimitiveOverride", "@Override");
-		addValueAnnontion("@ValuePrimitive", "@Deprecated");
-		return this;
-	}
-	
-	public GlobalVariables createHelperVariables()
-	{
-		createHelperVars(type, false, "KEY");
-		createHelperVars(valueType, true, "VALUE");
-		return this;
-	}
-	
-	private void createHelperVars(ClassType type, boolean value, String fix)
-	{
-		addArgumentMapper("EQUALS_"+fix+"_TYPE", "Objects.equals(%2$s, "+(type.isObject() ? "%1$s" : fix+"_TO_OBJ(%1$s)")+")").removeBraces();
-		addInjectMapper(fix+"_EQUALS_NOT_NULL", type.getComparableValue()+" != "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
-		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();
-		
-		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();
-		
-		addInjectMapper(fix+"_TO_OBJ", type.isObject() ? "%s" : type.getClassType(value)+".valueOf(%s)").removeBraces();
-		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
-		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
-		
-		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
-		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
-		
-		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
-		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();
-	}
-	
-	public GlobalVariables createPreFunctions()
-	{
-		addSimpleMapper("ENTRY_SET", type.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
-		return this;
-	}
-	
-	public GlobalVariables createClassTypes()
-	{
-		addSimpleMapper("JAVA_PREDICATE", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getFileType()+"Predicate");
-		addSimpleMapper("JAVA_CONSUMER", type.isPrimitiveBlocking() ? "" : "java.util.function."+type.getCustomJDKType().getFileType()+"Consumer");
-		addSimpleMapper("JAVA_SUPPLIER", type.isPrimitiveBlocking() ? "" : "java.util.function."+type.getCustomJDKType().getFileType()+"Supplier");
-		addSimpleMapper("JAVA_FUNCTION", type.getFunctionClass(valueType));
-		addSimpleMapper("JAVA_BINARY_OPERATOR", type == ClassType.BOOLEAN ? "" : (type.isObject() ? "java.util.function.BinaryOperator" : "java.util.function."+type.getCustomJDKType().getFileType()+"BinaryOperator"));
-		addSimpleMapper("JAVA_UNARY_OPERATOR", type.isObject() ? "BinaryOperator" : type == ClassType.BOOLEAN ? "" : type.getCustomJDKType().getFileType()+"UnaryOperator");
-		addSimpleMapper("JAVA_SPLIT_ITERATOR", type.isPrimitiveBlocking() ? "Spliterator" : "Of"+type.getCustomJDKType().getFileType());
-		addSimpleMapper("JAVA_STREAM", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getFileType()+"Stream");
-		addSimpleMapper("JAVA_BUFFER", type.getFileType()+"Buffer");
-		
-		//Final Classes
-		addClassMapper("ARRAY_LIST", "ArrayList");
-		addAbstractMapper("COPY_ON_WRITE_LIST", "CopyOnWrite%sArrayList");
-		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
-		addClassMapper("LINKED_LIST", "LinkedList");
-		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
-		addClassMapper("ARRAY_FIFO_QUEUE", "ArrayFIFOQueue");
-		addClassMapper("ARRAY_PRIORITY_QUEUE", "ArrayPriorityQueue");
-		addClassMapper("HEAP_PRIORITY_QUEUE", "HeapPriorityQueue");
-		addClassMapper("LINKED_CUSTOM_HASH_SET", "LinkedOpenCustomHashSet");
-		addClassMapper("LINKED_HASH_SET", "LinkedOpenHashSet");
-		addAbstractMapper("IMMUTABLE_HASH_SET", "Immutable%sOpenHashSet");
-		addClassMapper("CUSTOM_HASH_SET", "OpenCustomHashSet");
-		addClassMapper("HASH_SET", "OpenHashSet");
-		addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
-		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
-		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
-		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
-		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
-		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
-		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
-		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
-		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
-		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
-		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
-		addBiClassMapper("IMMUTABLE_PAIR", "ImmutablePair", "");
-		addBiClassMapper("MUTABLE_PAIR", "MutablePair", "");
-		addClassMapper("RB_TREE_SET", "RBTreeSet");
-		addClassMapper("AVL_TREE_SET", "AVLTreeSet");
-		addClassMapper("ARRAY_SET", "ArraySet");
-		
-		//Abstract Classes
-		addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
-		addAbstractMapper("ABSTRACT_PRIORITY_QUEUE", "Abstract%sPriorityQueue");
-		addAbstractMapper("ABSTRACT_SET", "Abstract%sSet");
-		addAbstractMapper("ABSTRACT_LIST", "Abstract%sList");
-		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
-		addClassMapper("SUB_LIST", "SubList");
-		addAbstractMapper("BASE_TASK", "Base%sTask");
-		
-		//Helper Classes
-		addClassMapper("LISTS", "Lists");
-		addClassMapper("SETS", "Sets");
-		addClassMapper("COLLECTIONS", "Collections");
-		addClassMapper("ARRAYS", "Arrays");
-		addClassMapper("PRIORITY_QUEUES", "PriorityQueues");
-		addClassMapper("SPLIT_ITERATORS", "Splititerators");
-		addClassMapper("ITERATORS", "Iterators");
-		addClassMapper("ITERABLES", "Iterables");
-		addBiClassMapper("MAPS", "Maps", "2");
-		
-		//Interfaces
-		addClassMapper("LIST_ITERATOR", "ListIterator");
-		addClassMapper("BI_ITERATOR", "BidirectionalIterator");
-		addBiClassMapper("BI_CONSUMER", "Consumer", "");
-		addClassMapper("BI_TO_OBJECT_CONSUMER", "ObjectConsumer");
-		addAbstractMapper("BI_FROM_OBJECT_CONSUMER", "Object%sConsumer");
-		addClassMapper("SPLIT_ITERATOR", "Splititerator");
-		addClassMapper("ITERATOR", "Iterator");
-		addClassMapper("ITERABLE", "Iterable");
-		addClassMapper("COLLECTION", "Collection");
-		addClassMapper("TO_OBJECT_FUNCTION", "2ObjectFunction");
-		addBiClassMapper("FUNCTION", "Function", "2");
-		addClassMapper("LIST_ITER", "ListIter");
-		addClassMapper("LIST", "List");
-		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
-		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
-		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
-		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
-		addBiClassMapper("MAP", "Map", "2");
-		addClassMapper("NAVIGABLE_SET", "NavigableSet");
-		addBiClassMapper("PAIR", "Pair", "");
-		addClassMapper("PRIORITY_QUEUE", "PriorityQueue");
-		addClassMapper("PRIORITY_DEQUEUE", "PriorityDequeue");
-		addClassMapper("PREDICATE", "2BooleanFunction");
-		addClassMapper("SORTED_SET", "SortedSet");
-		addClassMapper("ORDERED_SET", "OrderedSet");
-		addClassMapper("SET", "Set");
-		addClassMapper("STRATEGY", "Strategy");
-		addClassMapper("STACK", "Stack");
-		addClassMapper("SUPPLIER", "Supplier");
-		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
-		addClassMapper("TASK", "Task");
-		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
-		if(type.isObject())
-		{
-			if(!valueType.isObject()) addSimpleMapper("VALUE_CONSUMER", valueType.getFileType()+"Consumer");
-			else addSimpleMapper("VALUE_CONSUMER", "Consumer");
-			addSimpleMapper("CONSUMER", "Consumer");
-			addSimpleMapper("COMPARATOR", "Comparator");	
-			addSimpleMapper("IARRAY", "IObjectArray");
-		}
-		else
-		{
-			if(valueType.isObject()) 
-			{
-				addSimpleMapper("VALUE_CONSUMER", "Consumer");
-				addSimpleMapper("CONSUMER", type.getFileType()+"Consumer");
-			}
-			else addClassMapper("CONSUMER", "Consumer");
-			addClassMapper("COMPARATOR", "Comparator");
-			addFunctionMappers("IARRAY", "I%sArray");
-		}
-		return this;
-	}
-	
-	public GlobalVariables createFunctions()
-	{
-		addSimpleMapper("APPLY_KEY_VALUE", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
-		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
-		addSimpleMapper("APPLY_CAST", "applyAs"+type.getCustomJDKType().getNonFileType());
-		addSimpleMapper("APPLY", type.isObject() ? "apply" : "applyAs"+type.getNonFileType());
-		addFunctionValueMapper("BULK_MERGE", "mergeAll");
-		addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
-		addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
-		addFunctionValueMapper("COMPUTE", "compute");
-		addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
-		addFunctionMapper("DEQUEUE", "dequeue");
-		addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
-		addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
-		addFunctionMapper("POLL_FIRST_KEY", "pollFirst");
-		addFunctionMapper("POLL_LAST_KEY", "pollLast");
-		addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
-		addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
-		addFunctionMapper("FIRST_KEY", "first");
-		addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
-		addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
-		addFunctionMappers("ENTRY_KEY", "get%sKey");
-		addFunctionValueMappers("ENTRY_VALUE", "get%sValue");
-		addFunctionMappers("KEY_ENTRY", "set%sKey");
-		addFunctionValueMappers("VALUE_ENTRY", "set%sValue");
-		addFunctionMapper("GET_KEY", "get");
-		if(type.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
-		else addSimpleMapper("GET_VALUE", "get");
-		addSimpleMapper("GET_JAVA", type.isObject() ? "get" : "getAs"+type.getCustomJDKType().getNonFileType());
-		addFunctionMapper("LAST_KEY", "last");
-		addFunctionValueMapper("MERGE", "merge");
-		addFunctionMapper("NEXT", "next");
-		addFunctionMapper("PREVIOUS", "previous");
-		addFunctionMapper("REMOVE_SWAP", "swapRemove");
-		if(type.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
-		else addSimpleMapper("REMOVE_VALUE", "remove");
-		addFunctionMapper("REMOVE_KEY", "rem");
-		addFunctionMapper("REMOVE_LAST", "removeLast");
-		addFunctionMapper("REMOVE", "remove");
-		addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
-		addFunctionMappers("REPLACE", type.isObject() ? "replaceObjects" : "replace%ss");
-		addFunctionMappers("SORT", "sort%ss");
-		addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
-		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("TO_ARRAY", "to"+type.getNonFileType()+"Array");
-		addSimpleMapper("[SPACE]", " ");
-		return this;
-	}
-	
-	public GlobalVariables createFlags()
-	{
-		flags.add("TYPE_"+type.getCapType());
-		flags.add("VALUE_"+valueType.getCapType());
-		if(type == valueType) flags.add("SAME_TYPE");
-		if(type.hasFunction(valueType)) flags.add("JDK_FUNCTION");
-		if(!type.needsCustomJDKType()) flags.add("JDK_TYPE");
-		if(!type.isPrimitiveBlocking()) flags.add("PRIMITIVES");
-		if(!valueType.isPrimitiveBlocking()) flags.add("VALUE_PRIMITIVES");
-		if(valueType.needsCustomJDKType()) flags.add("JDK_VALUE");
-		return this;
-	}
-	
-	public TemplateProcess create(String fileName, String splitter, boolean valueOnly)
-	{
-		TemplateProcess process = new TemplateProcess(String.format(fileName+".java", (splitter != null ? type.getFileType()+splitter+valueType.getFileType() : (valueOnly ? valueType : type).getFileType())));
-		process.setPathBuilder(new PathBuilder(type.getPathType()));
-		process.addFlags(flags);
-		process.addMappers(operators);
-		return process;
-	}
-	
-	public ClassType getType()
-	{
-		return type;
-	}
-	
-	private void addClassMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"[VALUE_"+pattern+"]", "VALUE_"+pattern, valueType.getFileType()+replacement));
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, type.getFileType()+replacement));
-	}
-	
-	private void addBiClassMapper(String pattern, String replacement, String splitter)
-	{
-		operators.add(new SimpleMapper(type.name()+"[KEY_"+pattern+"]", "KEY_"+pattern, type.getFileType()+splitter+type.getFileType()+replacement));
-		operators.add(new SimpleMapper(type.name()+"[VALUE_"+pattern+"]", "VALUE_"+pattern, valueType.getFileType()+splitter+valueType.getFileType()+replacement));
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, type.getFileType()+splitter+valueType.getFileType()+replacement));
-	}
-	
-	private void addAbstractMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"[VALUE_"+pattern+"]", "VALUE_"+pattern, String.format(replacement, valueType.getFileType())));
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, String.format(replacement, type.getFileType())));		
-	}
-	
-	private void addAbstractBiMapper(String pattern, String replacement, String splitter) 
-	{
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, String.format(replacement, type.getFileType()+splitter+valueType.getFileType())));
-	}
-	
-	private void addFunctionMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"[VALUE_"+pattern+"]", "VALUE_"+pattern, replacement+valueType.getNonFileType()));
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, replacement+type.getNonFileType()));
-	}
-	
-	private void addFunctionValueMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, replacement+valueType.getNonFileType()));
-	}
-	
-	private void addFunctionMappers(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"[VALUE_"+pattern+"]", "VALUE_"+pattern, String.format(replacement, valueType.getNonFileType())));		
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, String.format(replacement, type.getNonFileType())));		
-	}
-	
-	private void addFunctionValueMappers(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, String.format(replacement, valueType.getNonFileType())));		
-	}
-	
-	private void addSimpleMapper(String pattern, String replacement)
-	{
-		operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, replacement));
-	}
-	
-	private void addAnnontion(String pattern, String value)
-	{
-		if(type == ClassType.OBJECT) operators.add(new LineMapper(type.name()+"["+pattern+"]", pattern));
-		else operators.add(new SimpleMapper(type.name()+"["+pattern+"]", pattern, value));
-	}
-	
-	private void addValueAnnontion(String pattern, String value)
-	{
-		if(valueType == ClassType.OBJECT) operators.add(new LineMapper(valueType.name()+"["+pattern+"]", pattern));
-		else operators.add(new SimpleMapper(valueType.name()+"["+pattern+"]", pattern, value));
-	}
-	
-	private void addComment(String pattern, String value)
-	{
-		if(type == ClassType.OBJECT) operators.add(new InjectMapper(type.name()+"["+pattern+"]", pattern, value).removeBraces());
-		else operators.add(new LineMapper(type.name()+"["+pattern+"]", pattern));
-	}
-	
-	private void addValueComment(String pattern, String value)
-	{
-		if(valueType == ClassType.OBJECT) operators.add(new InjectMapper(valueType.name()+"["+pattern+"]", pattern, value).removeBraces());
-		else operators.add(new LineMapper(valueType.name()+"["+pattern+"]", pattern));
-	}
-	
-	private InjectMapper addInjectMapper(String pattern, String replacement)
-	{
-		InjectMapper mapper = new InjectMapper(type.name()+"["+pattern+"]", pattern, replacement);
-		operators.add(mapper);
-		return mapper;
-	}
-	
-	private ArgumentMapper addArgumentMapper(String pattern, String replacement)
-	{
-		return addArgumentMapper(pattern, replacement, ", ");
-	}
-	
-	private ArgumentMapper addArgumentMapper(String pattern, String replacement, String splitter)
-	{
-		ArgumentMapper mapper = new ArgumentMapper(type.name()+"["+pattern+"]", pattern, replacement, splitter);
-		operators.add(mapper);
-		return mapper;
-	}
-	
-	class PathBuilder implements UnaryOperator<Path>
-	{
-		String before;
-		
-		public PathBuilder(String before)
-		{
-			this.before = before;
-		}
-		
-		@Override
-		public Path apply(Path t)
-		{
-			return t.subpath(0, 6).resolve(before).resolve(t.subpath(6, t.getNameCount()));
-		}
-	}
-}

src/builder/java/speiger/src/builder/ModulePackage.java

@@ -0,0 +1,142 @@
+package speiger.src.builder;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+import speiger.src.builder.mappers.IMapper;
+import speiger.src.builder.processor.TemplateProcess;
+
+@SuppressWarnings("javadoc")
+public class ModulePackage
+{
+	private static final BiConsumer<String, RequiredType> VOID = (K, V) -> {};
+	public static final ClassType[] TYPE = ClassType.values();
+	final ClassType keyType;
+	final ClassType valueType;
+	Set<String> blocked = new HashSet<>();
+	Map<String, String> nameRemapper = new HashMap<>();
+	Map<String, String> splitters = new HashMap<>();
+	List<Predicate<String>> blockedFilters = new ArrayList<>();
+	List<IMapper> mappers = new ArrayList<>();
+	Set<String> flags = new LinkedHashSet<>();
+	BiConsumer<String, RequiredType> requirements = VOID;
+	
+	public ModulePackage(ClassType keyType, ClassType valueType) {
+		this.keyType = keyType;
+		this.valueType = valueType;
+	}
+	
+	public void finish() {
+		requirements = VOID;
+		mappers.sort(Comparator.comparing(IMapper::getSearchValue, Comparator.comparingInt(String::length).reversed()));
+		mappers.sort(Comparator.comparing(IMapper::getSearchValue, this::sort));
+	}
+	
+	public void setRequirements(BiConsumer<String, RequiredType> requirements) {
+		this.requirements = requirements;
+	}
+	
+	public boolean isSame() {
+		return keyType == valueType;
+	}
+	
+	public boolean isEnumValid() {
+		return keyType == ClassType.OBJECT;
+	}
+	
+	public ClassType getKeyType() {
+		return keyType;
+	}
+	
+	public ClassType getValueType() {
+		return valueType;
+	}
+	
+	public void addFlag(String flag) {
+		flags.add(flag);
+	}
+	
+	public void addRequirement(String fileName, RequiredType type) {
+		requirements.accept(fileName, type);
+	}
+	
+	public void addMapper(IMapper mapper) {
+		mappers.add(mapper);
+	}
+	
+	public void addBlockedFilter(Predicate<String> filter) {
+		blockedFilters.add(filter);
+	}
+	
+	public void addBlockedFiles(String... names) {
+		blocked.addAll(Arrays.asList(names));
+	}
+	
+	public void addSplitter(String fileName, String splitter) {
+		splitters.put(fileName, splitter);
+	}
+	
+	public void addRemapper(String fileName, String actualName) {
+		nameRemapper.put(fileName, actualName);
+	}
+	
+	public void process(String fileName, Consumer<TemplateProcess> result) {
+		if(isBlocked(fileName)) return;
+		String splitter = String.format(splitters.getOrDefault(fileName, keyType.getFileType()), keyType.getFileType(), valueType.getFileType());
+		String newName = String.format(nameRemapper.getOrDefault(fileName, "%s"+fileName), splitter);
+		TemplateProcess process = new TemplateProcess(newName+".java");
+		process.setPathBuilder(new PathBuilder(keyType.getPathType()));
+		process.addFlags(flags);
+		process.addMappers(mappers);
+		result.accept(process);
+	}
+	
+	private boolean isBlocked(String fileName) {
+		if(blocked.contains(fileName)) return true;
+		for(int i = 0,m=blockedFilters.size();i<m;i++) {
+			if(blockedFilters.get(i).test(fileName)) return true;
+		}
+		return false;
+	}
+	
+	public static List<ModulePackage> createPackages() {
+		List<ModulePackage> list = new ArrayList<>();
+		for(ClassType key : TYPE) {
+			for(ClassType value : TYPE) {
+				list.add(new ModulePackage(key, value));
+			}
+		}
+		return list;
+	}
+	
+	private int sort(String key, String value) {
+		if(value.contains(key)) return 1;
+		else if(key.contains(value)) return -1;
+		return 0;
+	}
+	
+	class PathBuilder implements UnaryOperator<Path> {
+		String before;
+		
+		public PathBuilder(String before) {
+			this.before = before;
+		}
+		
+		@Override
+		public Path apply(Path t) {
+			return t.subpath(0, 6).resolve(before).resolve(t.subpath(6, t.getNameCount()));
+		}
+	}
+}

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

@@ -6,7 +6,8 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.EnumSet;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -16,20 +17,32 @@ import java.util.StringJoiner;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
+import speiger.src.builder.modules.AsyncModule;
+import speiger.src.builder.modules.BaseModule;
+import speiger.src.builder.modules.CollectionModule;
+import speiger.src.builder.modules.FunctionModule;
+import speiger.src.builder.modules.JavaModule;
+import speiger.src.builder.modules.ListModule;
+import speiger.src.builder.modules.MapModule;
+import speiger.src.builder.modules.PairModule;
+import speiger.src.builder.modules.PrioQueueModule;
+import speiger.src.builder.modules.SetModule;
 import speiger.src.builder.processor.TemplateProcess;
 import speiger.src.builder.processor.TemplateProcessor;
 
 @SuppressWarnings("javadoc")
 public class PrimitiveCollectionsBuilder extends TemplateProcessor
 {
-	Map<String, EnumSet<ClassType>> blocked = new HashMap<>();
+	private static final int SPECIAL = 0x1; //Detects if the Builder is generating tests
-	Map<String, String> nameRemapper = new HashMap<>();
+	private static final int LOAD = 0x2; //If Configs should be loaded
-	Map<String, String> biRequired = new HashMap<>();
+	private static final int ANTI_SAVE = SPECIAL | LOAD; //If save should be disabled since load/save shouldn't happen at the same time.
-	Set<String> enumRequired = new HashSet<>();
+	private static final int SAVE = 0x4; //if the configuration should be created
-	public static final ClassType[] TYPE = ClassType.values();
+	List<ModulePackage> simplePackages = new ArrayList<>();
-	List<GlobalVariables> variables = new ArrayList<>();
+	List<ModulePackage> biPackages = new ArrayList<>();
-	List<GlobalVariables> biVariables = new ArrayList<>();
+	List<ModulePackage> enumPackages = new ArrayList<>();
-	List<GlobalVariables> enumVariables = new ArrayList<>();
+	Map<String, RequiredType> requirements = new HashMap<>();
+	SettingsManager manager = new SettingsManager();
+	int flags;
 	
 	public PrimitiveCollectionsBuilder()
 	{
@@ -51,6 +64,28 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 		super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
 	}
 	
+	private PrimitiveCollectionsBuilder setFlags(int flags) {
+		this.flags = flags;
+		if((flags & ANTI_SAVE) != 0) {
+			this.flags &= ~SAVE;
+		}
+		return this;
+	}
+	
+	private static PrimitiveCollectionsBuilder createTests(boolean silent, int flags) {
+		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/")).setFlags(flags | SPECIAL);
+	}
+	
+	private static PrimitiveCollectionsBuilder createTesters(boolean silent, int flags) {
+		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/")).setFlags(flags | SPECIAL);
+	}
+	
 	@Override
 	protected boolean isFileValid(Path fileName)
 	{
@@ -72,7 +107,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	@Override
 	protected void afterFinish()
 	{
-		if(getVersion() > 8) 
+		if((flags & SPECIAL) == 0 && getVersion() > 8) 
 		{
 			Path basePath = Paths.get("src/main/java");
 			try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
@@ -87,100 +122,62 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	}
 	
 	@Override
-	protected void init()
+	protected void init() 
 	{
-		variables.clear();
+		prepPackages();
-		for(ClassType clzType : TYPE)
+		//Init Modules here
-		{
+		addModule(new JavaModule());
-			for(ClassType subType : TYPE)
+		addModule(new FunctionModule());
-			{
+		addModule(new CollectionModule());
-				create(clzType, subType);
+		addModule(new PrioQueueModule());
-			}
+		addModule(new ListModule());
-		}
+		addModule(new SetModule());
-		enumRequired.add("EnumMap");
+		addModule(new MapModule());
-		enumRequired.add("LinkedEnumMap");
+		addModule(new PairModule());
-		biRequired.put("BiConsumer", "");
+		addModule(new AsyncModule());
-		biRequired.put("UnaryOperator", "");
+		finishPackages();
-		biRequired.put("Pair", "");
-		biRequired.put("MutablePair", "");
-		biRequired.put("ImmutablePair", "");
-		addBiClass("Function", "Maps", "Map", "SortedMap", "OrderedMap", "NavigableMap", "ConcurrentMap", "AbstractMap", "ConcurrentOpenHashMap", "ImmutableOpenHashMap", "OpenHashMap", "LinkedOpenHashMap", "OpenCustomHashMap", "LinkedOpenCustomHashMap", "ArrayMap", "RBTreeMap", "AVLTreeMap");
-		nameRemapper.put("BiConsumer", "%sConsumer");
-		nameRemapper.put("IArray", "I%sArray");
-		nameRemapper.put("AbstractMap", "Abstract%sMap");
-		nameRemapper.put("AbstractCollection", "Abstract%sCollection");
-		nameRemapper.put("AbstractPriorityQueue", "Abstract%sPriorityQueue");
-		nameRemapper.put("AbstractSet", "Abstract%sSet");
-		nameRemapper.put("AbstractList", "Abstract%sList");
-		nameRemapper.put("EnumMap", "Enum2%sMap");
-		nameRemapper.put("LinkedEnumMap", "LinkedEnum2%sMap");
-		nameRemapper.put("ImmutableList", "Immutable%sList");
-		nameRemapper.put("CopyOnWriteList", "CopyOnWrite%sArrayList");
-		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");
 	}
 	
-	protected void create(ClassType mainType, ClassType subType) 
+	public void addModule(BaseModule module)
 	{
-		GlobalVariables type = new GlobalVariables(mainType, subType);
+		module.setManager(manager);
-		type.createFlags();
+		biPackages.forEach(module::init);
-		type.createHelperVariables();
+		module.cleanup();
-		type.createVariables();
-		type.createPreFunctions();
-		type.createClassTypes();
-		type.createFunctions();
-		if(mainType == subType) variables.add(type);
-		biVariables.add(type);
-		if(mainType.isObject()) enumVariables.add(type);
 	}
 	
-	protected void addBiClass(String...classNames) 
+	private void finishPackages() 
 	{
-		for(String s : classNames)
+		biPackages.forEach(ModulePackage::finish);
-		{
+		if((flags & SAVE) != 0) manager.save();
-			biRequired.put(s, "2");
-		}
 	}
 	
-	protected void addBlockage(ClassType type, String...args) 
+	private void prepPackages()
 	{
-		for(String s : args) 
+		if((flags & LOAD) != 0) manager.load();
+		for(ModulePackage entry : ModulePackage.createPackages())
 		{
-			EnumSet<ClassType> set = blocked.get(s);
+			entry.setRequirements(requirements::put);
-			if(set == null) 
+			biPackages.add(entry);
-			{
+			if(entry.isSame()) simplePackages.add(entry);
-				set = EnumSet.noneOf(ClassType.class);
+			if(entry.isEnumValid()) enumPackages.add(entry);
-				blocked.put(s, set);
+		}		
-			}
-			set.add(type);
-		}
 	}
 	
 	@Override
-	public void createProcesses(String name, Consumer<TemplateProcess> acceptor)
+	public void createProcesses(String fileName, Consumer<TemplateProcess> process)
 	{
-		String splitter = biRequired.get(name);
+		List<ModulePackage> packages = getPackagesByRequirement(requirements.get(fileName));
-		boolean valueRequired = enumRequired.contains(name);
+		for(int i = 0,m=packages.size();i<m;i++)
-		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);
+			packages.get(i).process(fileName, process);
-			if(types == null || !types.contains(type.getType()))
-			{
-				acceptor.accept(type.create(nameRemapper.getOrDefault(name, "%s"+name), splitter, valueRequired));
-			}
 		}
 	}
 	
-	protected List<GlobalVariables> getVariablesByClass(String name, boolean bi) {
+	protected List<ModulePackage> getPackagesByRequirement(RequiredType type) {
-		if(enumRequired.contains(name)) return enumVariables;
+		if(type == null) return simplePackages;
-		if(bi) return biVariables;
+		if(type == RequiredType.BI_CLASS) return biPackages;
-		return variables;
+		if(type == RequiredType.ENUM) return enumPackages;
+		return Collections.emptyList();
 	}
 	
 	private String getModuleInfo(Path basePath) {
@@ -236,28 +233,22 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 	{
 		try
 		{
-	        if(args.length == 0) {
+			Set<String> flags = new HashSet<>(Arrays.asList(args));
-	            new PrimitiveCollectionsBuilder().process(false);
+			boolean silent = flags.contains("silent");
-	        } else if(args.length == 1) {
+			boolean force = flags.contains("force");
-	            new PrimitiveCollectionsBuilder().process(Boolean.parseBoolean(args[0]));
+			boolean tests = flags.contains("tests");
-	        } else if(args.length == 2) {
+			boolean forceTests =  flags.contains("force-tests");
-	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[1])).process(Boolean.parseBoolean(args[0]));
+			boolean load = flags.contains("load");
-	        } else if(args.length == 3) {
+			boolean save = !flags.contains("save");
-	            new PrimitiveCollectionsBuilder(Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(false);
+			int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
-	        } else if(args.length == 4) {
+//			new PrimitiveCollectionsBuilder(silent).test();
-	            new PrimitiveCollectionsBuilder(false, Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+            new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
-	        } else if(args.length == 4) {
+            if(tests) {
-	            new PrimitiveCollectionsBuilder(Boolean.parseBoolean(args[4]), Paths.get(args[0]), Paths.get(args[1]), Paths.get(args[2])).process(Boolean.parseBoolean(args[3]));
+    			createTests(silent, flag).process(force || forceTests);
-	        } else {
+    			createTesters(silent, flag).process(force || forceTests);
-	            System.out.println("Invalid argument count passed in");
+            }
-	            System.exit(1);
+        }
-	    	}
+		catch(InterruptedException | IOException e)
-		}
-		catch(InterruptedException e)
-		{
-			e.printStackTrace();
-		}
-		catch(IOException e)
 		{
 			e.printStackTrace();
 		}

src/builder/java/speiger/src/builder/RequiredType.java

@@ -0,0 +1,8 @@
+package speiger.src.builder;
+
+@SuppressWarnings("javadoc")
+public enum RequiredType
+{
+	BI_CLASS,
+	ENUM
+}

src/builder/java/speiger/src/builder/SettingsManager.java

@@ -0,0 +1,105 @@
+package speiger.src.builder;
+
+import java.io.BufferedReader;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Set;
+import java.util.TreeSet;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.internal.Streams;
+import com.google.gson.stream.JsonWriter;
+
+import speiger.src.builder.modules.BaseModule;
+
+@SuppressWarnings("javadoc")
+public class SettingsManager
+{
+	boolean loaded;
+	JsonObject data = new JsonObject();
+	Set<String> moduleNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+	
+	public boolean isModuleEnabled(BaseModule base, ClassType keyType, ClassType valueType, String entry)
+	{
+		if(!loaded) return true;
+		if(!isEnabled(data, base.getModuleName())) return false;
+		JsonObject result = getObject(data, keyType.getClassPath());
+		if(base.isBiModule()) result = getObject(result, valueType.getClassPath());
+		result = getObject(result, base.getModuleName());
+		return result.size() <= 0 || (isEnabled(result, "enabled") && isEnabled(result, entry));
+	}
+	
+	public void addModule(BaseModule module) {
+		if(loaded) return;
+		String moduleName = module.getModuleName();
+		moduleNames.add(moduleName);
+		data.addProperty(moduleName, true);
+		if(module.isBiModule()) {
+			for(ClassType keyType : ModulePackage.TYPE) {
+				for(ClassType valueType : ModulePackage.TYPE) {
+					JsonObject obj = new JsonObject();
+					obj.addProperty("enabled", true);
+					for(String key : module.getModuleKeys(keyType, valueType)) {
+						obj.addProperty(key, true);
+					}
+					addModule(keyType, valueType, true, moduleName, obj);
+				}
+			}
+			return;
+		}
+		for(ClassType keyType : ModulePackage.TYPE) {
+			JsonObject obj = new JsonObject();
+			obj.addProperty("enabled", true);
+			for(String key : module.getModuleKeys(keyType, keyType)) {
+				obj.addProperty(key, true);
+			}
+			addModule(keyType, keyType, false, moduleName, obj);			
+		}
+	}
+	
+	public void load() {
+		try(BufferedReader reader = Files.newBufferedReader(Paths.get("ModulSettings.json"))) {
+			data = JsonParser.parseReader(reader).getAsJsonObject();
+			loaded = true;
+		}
+		catch(Exception e) { e.printStackTrace(); }
+	}
+	
+	public void save() {
+		data.asMap().keySet().removeAll(moduleNames);
+		JsonObject result = new JsonObject();
+		for(String s : moduleNames) {
+			result.addProperty(s, true);
+		}
+		result.asMap().putAll(data.asMap());
+		
+		try(JsonWriter writer = new JsonWriter(Files.newBufferedWriter(Paths.get("ModulSettings.json")))) {
+			writer.setIndent("\t");
+			Streams.write(result, writer);
+		}
+		catch(Exception e) { e.printStackTrace(); }
+	}
+	
+	private void addModule(ClassType keyType, ClassType valueType, boolean bi, String moduleName, JsonObject obj) {
+		JsonObject result = getObject(data, keyType.getClassPath());
+		if(bi) {
+			result = getObject(result, valueType.getClassPath());
+		}
+		result.add(moduleName, obj);
+	}
+	
+	private JsonObject getObject(JsonObject data, String name) {
+		JsonObject obj = data.getAsJsonObject(name);
+		if(obj == null) {
+			obj = new JsonObject();
+			data.add(name, obj);
+		}
+		return obj;
+	}
+	
+	private boolean isEnabled(JsonObject obj, String key) {
+		if(obj.has(key)) return obj.getAsJsonPrimitive(key).getAsBoolean();
+		return true;
+	}
+}

src/builder/java/speiger/src/builder/modules/AsyncModule.java

@@ -0,0 +1,28 @@
+package speiger.src.builder.modules;
+
+@SuppressWarnings("javadoc")
+public class AsyncModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Async"; }
+	@Override
+	protected void loadVariables() {}
+	@Override
+	protected void loadRemappers() {}
+	@Override
+	protected void loadTestClasses() {}
+	@Override
+	protected void loadFunctions() {}
+	@Override
+	protected void loadFlags() {}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Abstract Classes
+		addAbstractMapper("BASE_TASK", "Base%sTask");
+		
+		//Interfaces
+		addClassMapper("TASK", "Task");
+	}
+}

src/builder/java/speiger/src/builder/modules/BaseModule.java

@@ -0,0 +1,178 @@
+package speiger.src.builder.modules;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import speiger.src.builder.ClassType;
+import speiger.src.builder.ModulePackage;
+import speiger.src.builder.RequiredType;
+import speiger.src.builder.SettingsManager;
+import speiger.src.builder.mappers.ArgumentMapper;
+import speiger.src.builder.mappers.InjectMapper;
+import speiger.src.builder.mappers.LineMapper;
+import speiger.src.builder.mappers.SimpleMapper;
+
+@SuppressWarnings("javadoc")
+public abstract class BaseModule
+{
+	SettingsManager manager;
+	ModulePackage entry;
+	protected ClassType keyType;
+	protected ClassType valueType;
+	
+	public final void setManager(SettingsManager manager) {
+		this.manager = manager;
+		manager.addModule(this);
+	}
+	
+	public final void init(ModulePackage entry) {
+		this.entry = entry;
+		keyType = entry.getKeyType();
+		valueType = entry.getValueType();
+		loadVariables();
+		loadClasses();
+		loadTestClasses();
+		loadFunctions();
+		loadRemappers();
+		loadFlags();
+	}
+	
+	public final void cleanup() {
+		entry = null;
+		keyType = null;
+		valueType = null;
+		manager = null;
+	}
+	
+	protected abstract void loadVariables();
+	protected abstract void loadClasses();
+	protected abstract void loadTestClasses();
+	protected abstract void loadFunctions();
+	protected abstract void loadRemappers();
+	protected abstract void loadFlags();
+	
+	public abstract String getModuleName();
+	public boolean isBiModule() { return false; }
+	public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) { return Collections.emptySet(); }
+	
+	protected boolean isModuleEnabled(String name) {
+		if(manager == null) return true;
+		return manager.isModuleEnabled(this, keyType, valueType, name);
+	}
+	
+	protected void addFlag(String name) {
+		entry.addFlag(name);
+	}
+	
+	protected void addBiRequirement(String fileName) {
+		entry.addRequirement(fileName, RequiredType.BI_CLASS);
+		entry.addSplitter(fileName, "%1$s2%2$s");
+	}
+	
+	protected void addEnumRequirement(String fileName) {
+		entry.addRequirement(fileName, RequiredType.ENUM);
+		entry.addSplitter(fileName, "%2$s");
+
+	}
+	
+	protected void addBiRequirement(String fileName, String splitter) {
+		entry.addRequirement(fileName, RequiredType.BI_CLASS);
+		entry.addSplitter(fileName, "%1$s"+splitter+"%2$s");
+	}
+	
+	protected void addRequirement(String fileName, String splitter, RequiredType type) {
+		entry.addRequirement(fileName, type);
+		entry.addSplitter(fileName, splitter);
+	}
+	
+	protected void addRemapper(String fileName, String actualName) {
+		entry.addRemapper(fileName, actualName);
+	}
+	
+	protected void addBlockedFiles(String... name) {
+		entry.addBlockedFiles(name);
+	}
+	
+	protected void addBlockedFilter(Predicate<String> filter) {
+		entry.addBlockedFilter(filter);
+	}
+	
+	protected void addClassMapper(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, valueType.getFileType()+replacement));
+		entry.addMapper(new SimpleMapper(pattern, pattern, keyType.getFileType()+replacement));
+	}
+	
+	protected void addBiClassMapper(String pattern, String replacement, String splitter) {
+		entry.addMapper(new SimpleMapper("KEY_"+pattern, "KEY_"+pattern, keyType.getFileType()+splitter+keyType.getFileType()+replacement));
+		entry.addMapper(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, valueType.getFileType()+splitter+valueType.getFileType()+replacement));
+		entry.addMapper(new SimpleMapper(pattern, pattern, keyType.getFileType()+splitter+valueType.getFileType()+replacement));
+	}
+	
+	protected void addAbstractMapper(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, String.format(replacement, valueType.getFileType())));
+		entry.addMapper(new SimpleMapper(pattern, pattern, String.format(replacement, keyType.getFileType())));		
+	}
+	
+	protected void addAbstractBiMapper(String pattern, String replacement, String splitter) {
+		entry.addMapper(new SimpleMapper(pattern, pattern, String.format(replacement, keyType.getFileType()+splitter+valueType.getFileType())));
+	}
+	
+	protected void addFunctionMapper(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, replacement+valueType.getNonFileType()));
+		entry.addMapper(new SimpleMapper(pattern, pattern, replacement+keyType.getNonFileType()));
+	}
+	
+	protected void addFunctionValueMapper(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper(pattern, pattern, replacement+valueType.getNonFileType()));
+	}
+	
+	protected void addFunctionMappers(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper("VALUE_"+pattern, "VALUE_"+pattern, String.format(replacement, valueType.getNonFileType())));		
+		entry.addMapper(new SimpleMapper(pattern, pattern, String.format(replacement, keyType.getNonFileType())));		
+	}
+	
+	protected void addFunctionValueMappers(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper(pattern, pattern, String.format(replacement, valueType.getNonFileType())));		
+	}
+	
+	protected void addSimpleMapper(String pattern, String replacement) {
+		entry.addMapper(new SimpleMapper(pattern, pattern, replacement));
+	}
+	
+	protected void addAnnontion(String pattern, String value) {
+		if(keyType == ClassType.OBJECT) entry.addMapper(new LineMapper(pattern, pattern));
+		else entry.addMapper(new SimpleMapper(pattern, pattern, value));
+	}
+	
+	protected void addValueAnnontion(String pattern, String value) {
+		if(valueType == ClassType.OBJECT) entry.addMapper(new LineMapper(pattern, pattern));
+		else entry.addMapper(new SimpleMapper(pattern, pattern, value));
+	}
+	
+	protected void addComment(String pattern, String value) {
+		if(keyType == ClassType.OBJECT) entry.addMapper(new InjectMapper(pattern, pattern, value).removeBraces());
+		else entry.addMapper(new LineMapper(pattern, pattern));
+	}
+	
+	protected void addValueComment(String pattern, String value) {
+		if(valueType == ClassType.OBJECT) entry.addMapper(new InjectMapper(pattern, pattern, value).removeBraces());
+		else entry.addMapper(new LineMapper(pattern, pattern));
+	}
+	
+	protected InjectMapper addInjectMapper(String pattern, String replacement) {
+		InjectMapper mapper = new InjectMapper(pattern, pattern, replacement);
+		entry.addMapper(mapper);
+		return mapper;
+	}
+	
+	protected ArgumentMapper addArgumentMapper(String pattern, String replacement) {
+		return addArgumentMapper(pattern, replacement, ", ");
+	}
+	
+	protected ArgumentMapper addArgumentMapper(String pattern, String replacement, String splitter) {
+		ArgumentMapper mapper = new ArgumentMapper(pattern, pattern, replacement, splitter);
+		entry.addMapper(mapper);
+		return mapper;
+	}
+}

src/builder/java/speiger/src/builder/modules/CollectionModule.java

@@ -0,0 +1,99 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class CollectionModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Collection"; }
+	@Override
+	protected void loadVariables() { loadBlockades(); }
+	@Override
+	protected void loadFlags() {}
+	
+	private void loadBlockades()
+	{
+		if(keyType.isObject()) {
+			addBlockedFiles("Stack");
+			addBlockedFiles("CollectionStreamTester");
+		}
+		if(keyType == ClassType.BOOLEAN) {
+			addBlockedFiles("CollectionRemoveIfTester", "CollectionStreamTester");
+			addBlockedFilter(T -> T.endsWith("Tester") && T.startsWith("Iterable"));
+		}
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addRemapper("IArray", "I%sArray");
+		addRemapper("AbstractCollection", "Abstract%sCollection");
+		
+		//Test Classes
+		addRemapper("AbstractIteratorTester", "Abstract%sIteratorTester");
+		addRemapper("MinimalCollection", "Minimal%sCollection");
+		addRemapper("TestCollectionGenerator", "Test%sCollectionGenerator");
+		addRemapper("AbstractContainerTester", "Abstract%sContainerTester");
+		addRemapper("AbstractCollectionTester", "Abstract%sCollectionTester");
+		addRemapper("SimpleTestGenerator", "Simple%sTestGenerator");
+	}
+	
+	@Override
+	protected void loadFunctions()
+	{
+		addFunctionMapper("NEXT", "next");
+		addSimpleMapper("NEW_STREAM", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getKeyType()+"Stream");
+		addFunctionMapper("PREVIOUS", "previous");
+		addFunctionMapper("REMOVE_KEY", "rem");
+		addSimpleMapper("TO_ARRAY", "to"+keyType.getNonFileType()+"Array");
+		addSimpleMapper("VALUE_TO_ARRAY", "to"+valueType.getNonFileType()+"Array");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
+		
+		//Helper Classes
+		addClassMapper("ARRAYS", "Arrays");
+		addClassMapper("COLLECTIONS", "Collections");
+		addClassMapper("ITERABLES", "Iterables");
+		addClassMapper("SPLIT_ITERATORS", "Splititerators");
+		addClassMapper("ITERATORS", "Iterators");
+		
+		//Interfaces
+		addClassMapper("COLLECTION", "Collection");
+		addClassMapper("ITERABLE", "Iterable");
+		addClassMapper("SPLIT_ITERATOR", "Splititerator");
+		addClassMapper("LIST_ITERATOR", "ListIterator");
+		addClassMapper("BI_ITERATOR", "BidirectionalIterator");
+		addClassMapper("ITERATOR", "Iterator");
+		addClassMapper("STACK", "Stack");
+		addClassMapper("STRATEGY", "Strategy");
+	}
+	
+	@Override
+	protected void loadTestClasses()
+	{
+		//Implementation Classes
+		addAbstractMapper("MINIMAL_COLLECTION", "Minimal%sCollection");
+		addClassMapper("BIDIRECTIONAL_ITERATOR_TESTER", "BidirectionalteratorTester");
+		addClassMapper("LIST_ITERATOR_TESTER", "ListIteratorTester");
+		addClassMapper("ITERATOR_TESTER", "IteratorTester");
+		addClassMapper("COLLECTION_TEST_BUILDER", "CollectionTestSuiteBuilder");
+		addClassMapper("COLLECTION_CONSTRUCTOR_TESTS", "CollectionConstructorTests");
+		
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_COLLECTION_TESTER", "Abstract%sCollectionTester");
+		addAbstractMapper("ABSTRACT_CONTAINER_TESTER", "Abstract%sContainerTester");
+		addAbstractMapper("ABSTRACT_ITERATOR_TESTER", "Abstract%sIteratorTester");
+		
+		//Helper Classes
+		addAbstractMapper("TEST_COLLECTION_GENERATOR", "Test%sCollectionGenerator");
+		addAbstractMapper("SIMPLE_TEST_GENERATOR", "Simple%sTestGenerator");
+
+	}
+}

src/builder/java/speiger/src/builder/modules/FunctionModule.java

@@ -0,0 +1,71 @@
+package speiger.src.builder.modules;
+
+@SuppressWarnings("javadoc")
+public class FunctionModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Function"; }
+	@Override
+	public boolean isBiModule() { return true; }
+	@Override
+	protected void loadVariables() { loadBlockades(); }
+	@Override
+	protected void loadFlags() {}
+	@Override
+	protected void loadTestClasses() {}
+	
+	private void loadBlockades()
+	{
+		if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator");
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		addBiRequirement("BiConsumer", "");
+		addBiRequirement("UnaryOperator", "");
+		addBiRequirement("Function");
+		addRemapper("BiConsumer", "%sConsumer");
+	}
+	
+	@Override
+	protected void loadFunctions()
+	{
+		addSimpleMapper("VALUE_TEST_VALUE", valueType.isObject() ? "getBoolean" : "get");
+		addSimpleMapper("TEST_VALUE", keyType.isObject() ? "getBoolean" : "get");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Interfaces
+		addBiClassMapper("BI_CONSUMER", "Consumer", "");
+		addClassMapper("BI_TO_OBJECT_CONSUMER", "ObjectConsumer");
+		addAbstractMapper("BI_FROM_OBJECT_CONSUMER", "Object%sConsumer");
+		addClassMapper("TO_OBJECT_FUNCTION", "2ObjectFunction");
+		addBiClassMapper("FUNCTION", "Function", "2");
+		addClassMapper("PREDICATE", "2BooleanFunction");
+		addClassMapper("SUPPLIER", "Supplier");
+		addAbstractMapper("SINGLE_UNARY_OPERATOR", "%1$s%1$sUnaryOperator");
+		addBiClassMapper("UNARY_OPERATOR", "UnaryOperator", "");
+		if(keyType.isObject())
+		{
+			if(!valueType.isObject()) addSimpleMapper("VALUE_CONSUMER", valueType.getFileType()+"Consumer");
+			else addSimpleMapper("VALUE_CONSUMER", "Consumer");
+			addSimpleMapper("CONSUMER", "Consumer");
+			addSimpleMapper("IARRAY", "IObjectArray");
+		}
+		else
+		{
+			if(valueType.isObject()) 
+			{
+				addSimpleMapper("VALUE_CONSUMER", "Consumer");
+				addSimpleMapper("CONSUMER", keyType.getFileType()+"Consumer");
+			}
+			else addClassMapper("CONSUMER", "Consumer");
+			addFunctionMappers("IARRAY", "I%sArray");
+		}
+		addSimpleMapper("VALUE_COMPARATOR", valueType.isObject() ? "Comparator" : String.format("%sComparator", valueType.getNonFileType()));
+		addSimpleMapper("COMPARATOR", keyType.isObject() ? "Comparator" : String.format("%sComparator", keyType.getNonFileType()));
+	}
+}

src/builder/java/speiger/src/builder/modules/JavaModule.java

@@ -0,0 +1,201 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class JavaModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Base"; }
+	@Override
+	protected void loadVariables()
+	{
+		createHelperVars(keyType, false, "KEY");
+		createHelperVars(valueType, true, "VALUE");
+		loadBaseVariables();
+	}
+	
+	@Override
+	protected void loadFlags()
+	{
+		addFlag("TYPE_"+keyType.getCapType());
+		addFlag("VALUE_"+valueType.getCapType());
+		if(keyType == valueType) addFlag("SAME_TYPE");
+		if(keyType.hasFunction(valueType)) addFlag("JDK_FUNCTION");
+		if(!keyType.needsCustomJDKType()) addFlag("JDK_TYPE");
+		if(!keyType.isPrimitiveBlocking()) addFlag("PRIMITIVES");
+		if(!valueType.isPrimitiveBlocking()) addFlag("VALUE_PRIMITIVES");
+		if(valueType.needsCustomJDKType()) addFlag("JDK_VALUE");
+	}
+	
+	@Override
+	protected void loadRemappers() {}
+
+	@Override
+	protected void loadFunctions()
+	{
+		addSimpleMapper("APPLY_KEY_VALUE", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
+		addSimpleMapper("APPLY_VALUE", valueType.isObject() ? "apply" : "applyAs"+valueType.getNonFileType());
+		addSimpleMapper("APPLY_CAST", "applyAs"+keyType.getCustomJDKType().getNonFileType());
+		addSimpleMapper("APPLY", keyType.isObject() ? "apply" : "applyAs"+keyType.getNonFileType());
+		
+		//Shared by Maps and Pairs so moved to java.
+		addFunctionMappers("ENTRY_KEY", "get%sKey");
+		addFunctionValueMappers("ENTRY_VALUE", "get%sValue");
+		addFunctionMappers("KEY_ENTRY", "set%sKey");
+		addFunctionValueMappers("VALUE_ENTRY", "set%sValue");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		addSimpleMapper("JAVA_PREDICATE", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Predicate");
+		addSimpleMapper("JAVA_CONSUMER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Consumer");
+		addSimpleMapper("JAVA_SUPPLIER", keyType.isPrimitiveBlocking() ? "" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"Supplier");
+		addSimpleMapper("JAVA_FUNCTION", keyType.getFunctionClass(valueType));
+		addSimpleMapper("JAVA_BINARY_OPERATOR", keyType == ClassType.BOOLEAN ? "" : (keyType.isObject() ? "java.util.function.BinaryOperator" : "java.util.function."+keyType.getCustomJDKType().getFileType()+"BinaryOperator"));
+		addSimpleMapper("JAVA_UNARY_OPERATOR", keyType.isObject() ? "BinaryOperator" : keyType == ClassType.BOOLEAN ? "" : keyType.getCustomJDKType().getFileType()+"UnaryOperator");
+		addSimpleMapper("JAVA_SPLIT_ITERATOR", keyType.isPrimitiveBlocking() ? "Spliterator" : "Of"+keyType.getCustomJDKType().getFileType());
+		addSimpleMapper("JAVA_STREAM", keyType.isPrimitiveBlocking() ? "" : keyType.getCustomJDKType().getFileType()+"Stream");
+		addSimpleMapper("JAVA_BUFFER", keyType.getFileType()+"Buffer");
+	}
+	
+	@Override
+	protected void loadTestClasses()
+	{
+		addClassMapper("HELPERS", "Helpers");
+		addClassMapper("SAMPLE_ELEMENTS", "Samples");
+	}
+	
+	private void loadBaseVariables()
+	{
+		addSimpleMapper("VALUE_PACKAGE", valueType.getPathType());
+		addSimpleMapper("PACKAGE", keyType.getPathType());
+		addSimpleMapper("CLASS_TYPE", keyType.getClassType());
+		addSimpleMapper("CLASS_VALUE_TYPE", valueType.getClassValueType());
+		addSimpleMapper("KEY_TYPE", keyType.getKeyType());
+		addSimpleMapper("KEY_OBJECT_TYPE", keyType.isObject() ? "Object" : keyType.getKeyType());
+		addSimpleMapper("KEY_STRING_TYPE", keyType.isObject() ? "String" : keyType.getKeyType());
+		addSimpleMapper("KEY_SPECIAL_TYPE", keyType.isObject() ? "E" : keyType.getKeyType());
+		addSimpleMapper("CLASS_OBJECT_TYPE", keyType.getClassType());
+		addSimpleMapper("CLASS_OBJECT_VALUE_TYPE", valueType.getClassValueType());
+		addSimpleMapper("CLASS_STRING_TYPE", keyType.isObject() ? "String" : keyType.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", keyType.getCustomJDKType().getKeyType());
+		addSimpleMapper("VALUE_JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
+		
+		addSimpleMapper("EMPTY_KEY_VALUE", keyType.getEmptyValue());
+		addSimpleMapper("EMPTY_VALUE", valueType.getEmptyValue());
+		
+		addSimpleMapper("INVALID_KEY_VALUE", keyType.getInvalidValue());
+		addSimpleMapper("INVALID_VALUE", valueType.getInvalidValue());
+		
+		addSimpleMapper(" KEY_STRING_GENERIC_TYPE", keyType.isObject() ? "<String>" : "");
+		addSimpleMapper(" VALUE_STRING_GENERIC_TYPE", valueType.isObject() ? "<String>" : "");
+		addSimpleMapper(" KEY_VALUE_STRING_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<String, String>" : "<String>") : (valueType.isObject() ? "<String>" : ""));
+
+		
+		addSimpleMapper(" KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" KEY_KEY_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", "+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" KEY_CLASS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.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", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" KEY_VALUE_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+", "+valueType.getValueType()+">" : ""));
+		addInjectMapper(" KEY_VALUE_SPECIAL_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+", %s>" : "<"+keyType.getKeyType()+", %s>") : (valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>")).setBraceType("<>").removeBraces();
+		
+		addSimpleMapper(" NO_GENERIC_TYPE", keyType.isObject() ? "<?>" : "");
+		addSimpleMapper(" NO_KV_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<?, ?>" : "<?>") : valueType.isObject() ? "<?>" : "");
+		addSimpleMapper(" KEY_COMPAREABLE_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+" extends Comparable<T>>" : "");
+		
+		addSimpleMapper(" KEY_SUPER_GENERIC_TYPE", keyType.isObject() ? "<? super "+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" VALUE_SUPER_GENERIC_TYPE", valueType.isObject() ? "<? super "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_SUPER_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? super "+keyType.getKeyType()+", ? super "+valueType.getValueType()+">" : "<? super "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? super "+valueType.getValueType()+">" : ""));
+		
+		addSimpleMapper(" KEY_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? "<? extends "+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" VALUE_UNKNOWN_GENERIC_TYPE", valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : "");
+		addSimpleMapper(" KEY_VALUE_UNKNOWN_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<? extends "+keyType.getKeyType()+", ? extends "+valueType.getValueType()+">" : "<? extends "+keyType.getKeyType()+">") : (valueType.isObject() ? "<? extends "+valueType.getValueType()+">" : ""));
+
+		addSimpleMapper(" KEY_ENUM_VALUE_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : "<"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? "<"+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" KEY_VALUE_ENUM_GENERIC_TYPE", keyType.isObject() ? (valueType.isObject() ? "<"+keyType.getKeyType()+", "+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : "<"+keyType.getKeyType()+">") : (valueType.isObject() ? "<"+valueType.getValueType()+" extends Enum<"+valueType.getValueType()+">>" : ""));
+		
+		addInjectMapper(" KEY_SPECIAL_GENERIC_TYPE", keyType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
+		addInjectMapper(" VALUE_SPECIAL_GENERIC_TYPE", valueType.isObject() ? "<%s>" : "").removeBraces().setBraceType("<>");
+		addInjectMapper(" KSK_GENERIC_TYPE", keyType.isObject() ? "<%s, "+keyType.getKeyType()+">" : "<%s>").removeBraces().setBraceType("<>");
+		addInjectMapper(" KKS_GENERIC_TYPE", keyType.isObject() ? "<"+keyType.getKeyType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
+		addArgumentMapper(" KSS_GENERIC_TYPE", keyType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
+		addInjectMapper(" VSV_GENERIC_TYPE", valueType.isObject() ? "<%s, "+valueType.getValueType()+">" : "<%s>").removeBraces().setBraceType("<>");
+		addInjectMapper(" VVS_GENERIC_TYPE", valueType.isObject() ? "<"+valueType.getValueType()+", %s>" : "<%s>").removeBraces().setBraceType("<>");
+		addArgumentMapper(" VSS_GENERIC_TYPE", valueType.isObject() ? "<%1$s, %2$s>" : "<%2$s>").removeBraces().setBraceType("<>");		
+
+		addSimpleMapper(" GENERIC_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+">" : "");
+		addSimpleMapper(" GENERIC_VALUE_BRACES", valueType.isObject() ? " <"+valueType.getValueType()+">" : "");
+		addInjectMapper(" GENERIC_SPECIAL_KEY_BRACES", keyType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
+		addInjectMapper(" GENERIC_SPECIAL_VALUE_BRACES", valueType.isObject() ? " <%s>" : "").removeBraces().setBraceType("<>");
+		addSimpleMapper(" GENERIC_KEY_ENUM_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">, "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+" extends Enum<"+keyType.getKeyType()+">>") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
+		
+		addInjectMapper(" GENERIC_KEY_SPECIAL_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
+		addInjectMapper(" GENERIC_VALUE_SPECIAL_BRACES", valueType.isObject() ? " <"+valueType.getKeyType()+", %s>" : " <%s>").removeBraces().setBraceType("<>");
+		
+		addSimpleMapper(" GENERIC_KEY_VALUE_BRACES", keyType.isObject() ? (valueType.isObject() ? " <"+keyType.getKeyType()+", "+valueType.getValueType()+">" : " <"+keyType.getKeyType()+">") : (valueType.isObject() ? " <"+valueType.getValueType()+">" : ""));
+		addSimpleMapper(" COMPAREABLE_KEY_BRACES", keyType.isObject() ? " <"+keyType.getKeyType()+" extends Comparable<T>>" : "");
+		addSimpleMapper("KV_BRACES", keyType.isObject() || valueType.isObject() ? "<>" : "");
+		addSimpleMapper("VALUE_BRACES", valueType.isObject() ? "<>" : "");
+		addSimpleMapper("BRACES", keyType.isObject() ? "<>" : "");
+		if(keyType.needsCustomJDKType())
+		{
+			addSimpleMapper("JAVA_TYPE", keyType.getCustomJDKType().getKeyType());
+			addSimpleMapper("SANITY_CAST", "castTo"+keyType.getFileType());
+		}
+		addSimpleMapper("JAVA_CLASS", keyType.getCustomJDKType().getClassType());
+		if(valueType.needsCustomJDKType())
+		{
+			addSimpleMapper("SANITY_CAST_VALUE", "castTo"+valueType.getFileType());
+		}
+		addSimpleMapper("[SPACE]", " ");
+		addComment("@ArrayType", "@param <%s> the keyType of array that the operation should be applied");
+		addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection");
+		addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied");
+		addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection");
+		addAnnontion("@PrimitiveOverride", "@Override");
+		addSimpleMapper("@PrimitiveDoc", "");
+		addAnnontion("@Primitive", "@Deprecated");
+		addValueAnnontion("@ValuePrimitiveOverride", "@Override");
+		addValueAnnontion("@ValuePrimitive", "@Deprecated");
+	}
+	
+	private void createHelperVars(ClassType type, boolean value, String fix)
+	{
+		addArgumentMapper("EQUALS_"+fix+"_TYPE", "Objects.equals(%2$s, "+(type.isObject() ? "%1$s" : fix+"_TO_OBJ(%1$s)")+")").removeBraces();
+		addInjectMapper(fix+"_EQUALS_NOT_NULL", type.getComparableValue()+" != "+(type.isPrimitiveBlocking() || type.needsCast() ? type.getEmptyValue() : "0")).removeBraces();
+		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();
+		
+		addInjectMapper(fix+"_TO_OBJ", type.isObject() ? "%s" : type.getClassType(value)+".valueOf(%s)").removeBraces();
+		addInjectMapper("OBJ_TO_"+fix, type.isObject() ? "%s" : "%s."+type.getKeyType(value)+"Value()").removeBraces();
+		addInjectMapper("CLASS_TO_"+fix, type.isObject() ? "("+type.getKeyType(value)+")%s" : "(("+type.getClassType(value)+")%s)."+type.getKeyType(value)+"Value()").removeBraces();
+		
+		addInjectMapper(fix+"_TO_HASH", type.isObject() ? "Objects.hashCode(%s)" : type.getClassType(value)+".hashCode(%s)").removeBraces();
+		addInjectMapper(fix+"_TO_STRING", type.isObject() ? "Objects.toString(%s)" : type.getClassType(value)+".toString(%s)").removeBraces();
+		
+		addSimpleMapper("CAST_"+fix+"_ARRAY ", type.isObject() ? "("+fix+"_TYPE[])" : "");
+		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();
+		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();
+	}
+}

src/builder/java/speiger/src/builder/modules/ListModule.java

@@ -0,0 +1,87 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class ListModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "List"; }
+	@Override
+	protected void loadVariables() { loadBlockedFiles(); }
+	@Override
+	protected void loadFlags() {}
+	
+	private void loadBlockedFiles()
+	{
+		if(keyType.isObject()) {
+			addBlockedFiles("ListFillBufferTester");
+		}
+		if(keyType == ClassType.BOOLEAN) {
+			addBlockedFiles("ListFillBufferTester", "ListReplaceAllTester");
+		}
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addRemapper("AbstractList", "Abstract%sList");
+		addRemapper("ImmutableList", "Immutable%sList");
+		addRemapper("CopyOnWriteList", "CopyOnWrite%sArrayList");
+		
+		//Test Classes
+		addRemapper("AbstractListTester", "Abstract%sListTester");
+		addRemapper("AbstractListIndexOfTester", "Abstract%sListIndexOfTester");
+		addRemapper("TestListGenerator", "Test%sListGenerator");
+	}
+	
+	@Override
+	protected void loadFunctions()
+	{
+		addFunctionMapper("GET_KEY", "get");
+		addFunctionMapper("REMOVE_LAST", "removeLast");
+		addFunctionMapper("REMOVE_SWAP", "swapRemove");
+		addFunctionMappers("REPLACE", keyType.isObject() ? "replaceObjects" : "replace%ss");
+		addFunctionMappers("SORT", "sort%ss");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Implementation Classes
+		addClassMapper("ARRAY_LIST", "ArrayList");
+		addAbstractMapper("COPY_ON_WRITE_LIST", "CopyOnWrite%sArrayList");
+		addClassMapper("ASYNC_BUILDER", "AsyncBuilder");
+		addClassMapper("LINKED_LIST", "LinkedList");
+		addAbstractMapper("IMMUTABLE_LIST", "Immutable%sList");
+		
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_LIST", "Abstract%sList");
+		
+		//SubClasses
+		addClassMapper("SUB_LIST", "SubList");
+		addClassMapper("LIST_ITER", "ListIter");
+		
+		//Helper Classes
+		addClassMapper("LISTS", "Lists");
+		
+		//Interfaces
+		addClassMapper("LIST", "List");
+	}
+	
+	@Override
+	protected void loadTestClasses()
+	{
+		//Implementation Classes
+		addClassMapper("LIST_TEST_BUILDER", "ListTestSuiteBuilder");
+		addClassMapper("LIST_TESTS", "ListTests");
+
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_LIST_INDEX_OF_TESTER", "Abstract%sListIndexOfTester");
+		addAbstractMapper("ABSTRACT_LIST_TESTER", "Abstract%sListTester");
+		
+		//Helper classes
+		addAbstractMapper("TEST_LIST_GENERATOR", "Test%sListGenerator");
+	}
+}

src/builder/java/speiger/src/builder/modules/MapModule.java

@@ -0,0 +1,204 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class MapModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Map"; }
+	@Override
+	public boolean isBiModule() { return true; }
+	@Override
+	protected void loadVariables() { loadBlockades(); }
+	@Override
+	protected void loadFlags() {}
+	
+	private void loadBlockades()
+	{
+		if(keyType == ClassType.BOOLEAN)
+		{
+			//Main Classes
+			addBlockedFiles("SortedMap", "NavigableMap", "RBTreeMap", "AVLTreeMap");
+			addBlockedFiles("OrderedMap", "ArrayMap", "LinkedOpenHashMap", "LinkedOpenCustomHashMap");
+			addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
+			addBlockedFiles("ImmutableOpenHashMap", "OpenHashMap", "OpenCustomHashMap");
+			
+			//Test Classes
+			addBlockedFiles("TestMap", "MapTests", "MapTestSuiteBuilder", "MapConstructorTests", "TestMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester");
+			addBlockedFiles("TestSortedMapGenerator", "NavigableMapTestSuiteBuilder", "SortedMapTestSuiteBuilder");
+			addBlockedFiles("TestOrderedMapGenerator");
+			addBlockedFilter(T -> T.endsWith("Tester") && (T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
+		}
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addBiRequirement("Map");
+		addBiRequirement("SortedMap");
+		addBiRequirement("OrderedMap");
+		addBiRequirement("NavigableMap");
+		addBiRequirement("ConcurrentMap");
+		addBiRequirement("AbstractMap");
+		addEnumRequirement("EnumMap");
+		addEnumRequirement("LinkedEnumMap");
+		addBiRequirement("ConcurrentOpenHashMap");
+		addBiRequirement("ImmutableOpenHashMap");
+		addBiRequirement("OpenHashMap");
+		addBiRequirement("LinkedOpenHashMap");
+		addBiRequirement("OpenCustomHashMap");
+		addBiRequirement("LinkedOpenCustomHashMap");
+		addBiRequirement("ArrayMap");
+		addBiRequirement("RBTreeMap");
+		addBiRequirement("AVLTreeMap");
+		addBiRequirement("Maps");
+		
+		addRemapper("AbstractMap", "Abstract%sMap");
+		addRemapper("EnumMap", "Enum2%sMap");
+		addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
+		addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
+		
+		//Test Classes
+		addBiRequirement("TestMapGenerator");
+		addBiRequirement("TestSortedMapGenerator");
+		addBiRequirement("TestOrderedMapGenerator");
+		addBiRequirement("SimpleMapTestGenerator");
+		addBiRequirement("DerivedMapGenerators");
+		addBiRequirement("AbstractMapTester");
+		addBiRequirement("MapTestSuiteBuilder");
+		addBiRequirement("SortedMapTestSuiteBuilder");
+		addBiRequirement("NavigableMapTestSuiteBuilder");
+		addBiRequirement("OrderedMapTestSuiteBuilder");
+		addBiRequirement("MapTests");
+		addBiRequirement("MapConstructorTests");
+		addBiRequirement("TestMap");
+		addBiRequirement("MapAddToTester");
+		addBiRequirement("MapSubFromTester");
+		addBiRequirement("MapClearTester");
+		addBiRequirement("MapComputeIfAbsentTester");
+		addBiRequirement("MapComputeIfPresentTester");
+		addBiRequirement("MapComputeTester");
+		addBiRequirement("MapCopyTester");
+		addBiRequirement("MapContainsTester");
+		addBiRequirement("MapContainsKeyTester");
+		addBiRequirement("MapContainsValueTester");
+		addBiRequirement("MapCreatorTester");
+		addBiRequirement("MapEntrySetTester");
+		addBiRequirement("MapEqualsTester");
+		addBiRequirement("MapForEachTester");
+		addBiRequirement("MapGetOrDefaultTester");
+		addBiRequirement("MapGetTester");
+		addBiRequirement("MapHashCodeTester");
+		addBiRequirement("MapIsEmptyTester");
+		addBiRequirement("MapMergeTester");
+		addBiRequirement("MapMergeBulkTester");
+		addBiRequirement("MapPutAllArrayTester");
+		addBiRequirement("MapPutAllTester");
+		addBiRequirement("MapPutIfAbsentTester");
+		addBiRequirement("MapPutTester");
+		addBiRequirement("MapRemoveEntryTester");
+		addBiRequirement("MapRemoveOrDefaultTester");
+		addBiRequirement("MapRemoveTester");
+		addBiRequirement("MapReplaceAllTester");
+		addBiRequirement("MapReplaceEntryTester");
+		addBiRequirement("MapReplaceTester");
+		addBiRequirement("MapSizeTester");
+		addBiRequirement("MapSupplyIfAbsentTester");
+		addBiRequirement("MapToStringTester");
+		addBiRequirement("NavigableMapNavigationTester");
+		addBiRequirement("SortedMapNavigationTester");
+		addBiRequirement("OrderedMapNavigationTester");
+		addBiRequirement("OrderedMapMoveTester");
+		addBiRequirement("MapConstructorTester");
+		
+		addRemapper("TestMapGenerator", "Test%sMapGenerator");
+		addRemapper("TestSortedMapGenerator", "Test%sSortedMapGenerator");
+		addRemapper("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
+		addRemapper("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
+		addRemapper("DerivedMapGenerators", "Derived%sMapGenerators");
+		addRemapper("AbstractMapTester", "Abstract%sMapTester");
+		addRemapper("TestMap", "Test%sMap");
+	}
+	
+	@Override
+	protected void loadFunctions()
+	{
+		addFunctionValueMapper("BULK_MERGE", "mergeAll");
+		addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
+		addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
+		addFunctionValueMapper("COMPUTE", "compute");
+		addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
+		addFunctionMapper("DEQUEUE", "dequeue");
+		addSimpleMapper("ENTRY_SET", keyType.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
+		addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
+		addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
+		if(keyType.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
+		else addSimpleMapper("GET_VALUE", "get");
+		addSimpleMapper("GET_JAVA", keyType.isObject() ? "get" : "getAs"+keyType.getCustomJDKType().getNonFileType());
+		addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
+		addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
+		addFunctionValueMapper("MERGE", "merge");
+		addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
+		addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
+		if(keyType.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
+		else addSimpleMapper("REMOVE_VALUE", "remove");
+		addFunctionMapper("REMOVE", "remove");
+		addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
+		addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Implementation Classes
+		addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
+		addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
+		addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
+		addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
+		addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
+		addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
+		addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
+		addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
+		addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
+		addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
+		addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
+		
+		//Abstract Classes
+		addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
+		
+		//Helper Classes
+		addBiClassMapper("MAPS", "Maps", "2");
+		
+		//Interfaces
+		addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
+		addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
+		addBiClassMapper("SORTED_MAP", "SortedMap", "2");
+		addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
+		addBiClassMapper("MAP", "Map", "2");
+	}
+	
+	@Override
+	protected void loadTestClasses()
+	{
+		//Implementation Classes
+		addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
+		addBiClassMapper("MAP_TESTS", "MapTests", "2");
+		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");
+		
+		//Abstract Classes
+		addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
+		
+		//Helper Classes
+		addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
+		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");
+	}
+}

src/builder/java/speiger/src/builder/modules/PairModule.java

@@ -0,0 +1,41 @@
+package speiger.src.builder.modules;
+
+@SuppressWarnings("javadoc")
+public class PairModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Pair"; }
+	@Override
+	public boolean isBiModule() { return true; }
+	@Override
+	protected void loadVariables() {}
+	@Override
+	protected void loadFlags() {}
+	@Override
+	protected void loadFunctions() {}
+	@Override
+	protected void loadTestClasses() {}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addBiRequirement("Pair", "");
+		addBiRequirement("MutablePair", "");
+		addBiRequirement("ImmutablePair", "");
+		
+		//Test Classes
+		addBiRequirement("PairTester", "");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Implementations
+		addBiClassMapper("IMMUTABLE_PAIR", "ImmutablePair", "");
+		addBiClassMapper("MUTABLE_PAIR", "MutablePair", "");
+		
+		//Interfaces
+		addBiClassMapper("PAIR", "Pair", "");
+	}
+}

src/builder/java/speiger/src/builder/modules/PrioQueueModule.java

@@ -0,0 +1,70 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class PrioQueueModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "PriorityQueue"; }
+	@Override
+	protected void loadVariables() { loadBlockades(); }
+	@Override
+	protected void loadFlags() {}
+	@Override
+	protected void loadFunctions() {}
+	
+	private void loadBlockades()
+	{
+		if(keyType == ClassType.BOOLEAN) {
+			addBlockedFiles("QueueTests");
+		}
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addRemapper("AbstractPriorityQueue", "Abstract%sPriorityQueue");
+		
+		//Test Classes
+		addRemapper("TestQueueGenerator", "Test%sQueueGenerator");
+		addRemapper("AbstractQueueTester", "Abstract%sQueueTester");
+		addRemapper("SimpleQueueTestGenerator", "Simple%sQueueTestGenerator");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Implementation Classes
+		addClassMapper("ARRAY_FIFO_QUEUE", "ArrayFIFOQueue");
+		addClassMapper("ARRAY_PRIORITY_QUEUE", "ArrayPriorityQueue");
+		addClassMapper("HEAP_PRIORITY_QUEUE", "HeapPriorityQueue");
+		
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_PRIORITY_QUEUE", "Abstract%sPriorityQueue");
+		
+		//Helper Classes
+		addClassMapper("PRIORITY_QUEUES", "PriorityQueues");
+		
+		//Interfaces
+		addClassMapper("PRIORITY_QUEUE", "PriorityQueue");
+		addClassMapper("PRIORITY_DEQUEUE", "PriorityDequeue");	
+	}
+	
+	@Override
+	protected void loadTestClasses() 
+	{
+		//Implementation Classes
+		addClassMapper("DEQUEUE_TEST_BUILDER", "DequeueTestSuiteBuilder");
+		addClassMapper("QUEUE_TEST_BUILDER", "QueueTestSuiteBuilder");
+		addClassMapper("QUEUE_TESTS", "QueueTests");
+		
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_QUEUE_TESTER", "Abstract%sQueueTester");
+		
+		//Helper Classes
+		addAbstractMapper("SIMPLE_QUEUE_TEST_GENERATOR", "Simple%sQueueTestGenerator");
+		addAbstractMapper("TEST_QUEUE_GENERATOR", "Test%sQueueGenerator");
+	}
+}

src/builder/java/speiger/src/builder/modules/SetModule.java

@@ -0,0 +1,105 @@
+package speiger.src.builder.modules;
+
+import speiger.src.builder.ClassType;
+
+@SuppressWarnings("javadoc")
+public class SetModule extends BaseModule
+{
+	@Override
+	public String getModuleName() { return "Set"; }
+	@Override
+	protected void loadVariables() { loadBlockades(); }
+	@Override
+	protected void loadFlags() {}
+	
+	private void loadBlockades()
+	{
+		if(keyType == ClassType.BOOLEAN)
+		{
+			//Main Classes
+			addBlockedFiles("SortedSet", "NavigableSet", "AVLTreeSet", "RBTreeSet");
+			addBlockedFiles("OrderedSet", "ArraySet", "LinkedOpenHashSet", "LinkedOpenCustomHashSet");
+			addBlockedFiles("OpenHashSet", "OpenCustomHashSet", "ImmutableOpenHashSet");
+			
+			//Test Classes
+			addBlockedFiles("SetTests", "SetTestSuiteBuilder");
+			addBlockedFiles("OrderedSetTestSuiteBuilder", "TestOrderedSetGenerator", "OrderedSetMoveTester", "OrderedSetNavigationTester", "OrderedMapNavigationTester", "OrderedMapTestSuiteBuilder", "OrderedSetIterationTester");
+			addBlockedFiles("SortedSetTestSuiteBuilder", "TestSortedSetGenerator", "SortedSetNaviationTester", "SortedSetSubsetTestSetGenerator", "SortedSetIterationTester", "SortedSetNaviationTester");
+			addBlockedFiles("NavigableSetTestSuiteBuilder", "TestNavigableSetGenerator", "NavigableSetNavigationTester");
+		}
+	}
+	
+	@Override
+	protected void loadRemappers()
+	{
+		//Main Classes
+		addRemapper("AbstractSet", "Abstract%sSet");
+		addRemapper("ImmutableOpenHashSet", "Immutable%sOpenHashSet");
+		
+		//Test Classes
+		addRemapper("MinimalSet", "Minimal%sSet");
+		addRemapper("TestNavigableSetGenerator", "Test%sNavigableSetGenerator");
+		addRemapper("TestSortedSetGenerator", "Test%sSortedSetGenerator");
+		addRemapper("TestOrderedSetGenerator", "Test%sOrderedSetGenerator");
+		addRemapper("TestSetGenerator", "Test%sSetGenerator");
+		addRemapper("AbstractSetTester", "Abstract%sSetTester");
+	}
+	
+	@Override
+	protected void loadFunctions()
+	{
+		addFunctionMapper("POLL_FIRST_KEY", "pollFirst");
+		addFunctionMapper("POLL_LAST_KEY", "pollLast");
+		addFunctionMapper("FIRST_KEY", "first");
+		addFunctionMapper("LAST_KEY", "last");
+	}
+	
+	@Override
+	protected void loadTestClasses()
+	{
+		//Implementation Classes
+		addAbstractMapper("MINIMAL_SET", "Minimal%sSet");
+		addClassMapper("ORDERED_SET_TEST_BUILDER", "OrderedSetTestSuiteBuilder");
+		addClassMapper("SORTED_SET_TEST_BUILDER", "SortedSetTestSuiteBuilder");
+		addClassMapper("NAVIGABLE_SET_TEST_BUILDER", "NavigableSetTestSuiteBuilder");
+		addClassMapper("SET_TEST_BUILDER", "SetTestSuiteBuilder");
+		addClassMapper("SET_TESTS", "SetTests");
+
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_SET_TESTER", "Abstract%sSetTester");
+		
+		//Helper Classes
+		addClassMapper("SUB_SORTED_SET_CLASS_GENERATOR", "SortedSetSubsetTestSetGenerator");
+		addClassMapper("SUB_NAVIGABLE_SET_CLASS_GENERATOR", "NavigableSetSubsetTestSetGenerator");
+		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");
+	}
+	
+	@Override
+	protected void loadClasses()
+	{
+		//Implementation Classes
+		addClassMapper("LINKED_CUSTOM_HASH_SET", "LinkedOpenCustomHashSet");
+		addClassMapper("LINKED_HASH_SET", "LinkedOpenHashSet");
+		addAbstractMapper("IMMUTABLE_HASH_SET", "Immutable%sOpenHashSet");
+		addClassMapper("CUSTOM_HASH_SET", "OpenCustomHashSet");
+		addClassMapper("HASH_SET", "OpenHashSet");
+		addClassMapper("RB_TREE_SET", "RBTreeSet");
+		addClassMapper("AVL_TREE_SET", "AVLTreeSet");
+		addClassMapper("ARRAY_SET", "ArraySet");
+		
+		//Abstract Classes
+		addAbstractMapper("ABSTRACT_SET", "Abstract%sSet");
+		
+		//Helper Classes
+		addClassMapper("SETS", "Sets");
+		
+		//Interfaces
+		addClassMapper("NAVIGABLE_SET", "NavigableSet");
+		addClassMapper("SORTED_SET", "SortedSet");
+		addClassMapper("ORDERED_SET", "OrderedSet");
+		addClassMapper("SET", "Set");
+	}
+}

src/builder/resources/speiger/assets/collections/templates/collections/Collection.template

@@ -16,13 +16,14 @@ import speiger.src.collections.PACKAGE.functions.CONSUMER;
 #endif
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
+import speiger.src.collections.utils.ISizeProvider;
 import speiger.src.collections.utils.SanityChecks;
 
 /**
  * A Type-Specific {@link Collection} that reduces (un)boxing
  * @Type(T)
  */
-public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE
+public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE, ISizeProvider
 {
 #if !TYPE_OBJECT
 	/**

src/builder/resources/speiger/assets/collections/templates/collections/Iterable.template

@@ -10,6 +10,7 @@ import speiger.src.collections.objects.collections.ObjectIterable;
 #else
 import java.util.function.BiFunction;
 import java.util.Comparator;
+import speiger.src.collections.ints.functions.function.Int2ObjectFunction;
 
 #endif
 import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
@@ -26,6 +27,7 @@ import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
 import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
 import speiger.src.collections.PACKAGE.utils.ITERABLES;
 import speiger.src.collections.PACKAGE.utils.ITERATORS;
+import speiger.src.collections.utils.ISizeProvider;
 
 /**
  * A Type-Specific {@link Iterable} that reduces (un)boxing
@@ -117,6 +119,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @param <V> The return type supplier.
 	 * @param <E> The return type.
 	 * @return a new Iterable that returns the desired result
+	 * @note does not support TO_ARRAY optimizations.
 	 */
 	default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
 		return ITERABLES.flatMap(this, mapper);
@@ -127,6 +130,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * @param mapper the flatMapping function
 	 * @param <E> The return type.
 	 * @return a new Iterable that returns the desired result
+	 * @note does not support TO_ARRAY optimizations.
 	 */
 	default <E> ObjectIterable<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
 		return ITERABLES.arrayFlatMap(this, mapper);
@@ -136,6 +140,7 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	 * A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
 	 * @param filter the elements that should be kept.
 	 * @return a Iterable that filtered out all unwanted elements
+	 * @note does not support TO_ARRAY optimizations.
 	 */
 	default ITERABLE KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
 		return ITERABLES.filter(this, filter);
@@ -144,11 +149,21 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 	/**
 	 * A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
 	 * @return a Iterable that filtered out all duplicated elements
+	 * @note does not support TO_ARRAY optimizations.
 	 */
 	default ITERABLE KEY_GENERIC_TYPE distinct() {
 		return ITERABLES.distinct(this);
 	}
 	
+	/**
+	 * A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
+	 * @param repeats how many times the elements should be repeated
+	 * @return a Iterable that is repeating multiple times
+	 */
+	default ITERABLE KEY_GENERIC_TYPE repeat(int repeats) {
+		return ITERABLES.repeat(this, repeats);
+	}
+	
 	/**
 	 * A Helper function to reduce the usage of Streams and allows to limit the amount of elements
 	 * @param limit the amount of elements it should be limited to
@@ -204,6 +219,44 @@ public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
 		return pour(new LINKED_HASH_SETBRACES()); 		
 	}
 	
+#endif
+	
+#if TYPE_OBJECT
+	/**
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
+	 * @param action is the creator function of said Array to ensure type is kept.
+	 * @return a new Array of all elements
+	 */
+	default KEY_TYPE[] TO_ARRAY(Int2ObjectFunction<KEY_TYPE[]> action) {
+		ISizeProvider prov = ISizeProvider.of(this);
+		if(prov != null) {
+			int size = prov.size();
+			if(size >= 0) {
+				KEY_TYPE[] array = action.get(size);
+				ITERATORS.unwrap(array, iterator());
+				return array;
+			}
+		}
+		return ITERATORS.pour(iterator()).TO_ARRAY(action);
+	}
+#else
+	/**
+	 * A Helper function that reduces the usage of streams and allows to collect all elements as a Array
+	 * @return a new Array of all elements
+	 */
+	default KEY_TYPE[] TO_ARRAY() {
+		ISizeProvider prov = ISizeProvider.of(this);
+		if(prov != null) {
+			int size = prov.size();
+			if(size >= 0) {
+				KEY_TYPE[] array = NEW_KEY_ARRAY(size);
+				ITERATORS.unwrap(array, iterator());
+				return array;
+			}
+		}
+		return ITERATORS.pour(iterator()).TO_ARRAY();
+	}
+	
 #endif
 	/**
 	 * Helper function to reduce stream usage that allows to filter for any matches.

src/builder/resources/speiger/assets/collections/templates/maps/impl/concurrent/ConcurrentOpenHashMap.template

@@ -1812,6 +1812,11 @@ public class CONCURRENT_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY
 					insert(-slot-1, key, value);
 					return getDefaultReturnValue();
 				}
+				else if(VALUE_EQUALS(values[slot], getDefaultReturnValue())) {
+					VALUE_TYPE oldValue = values[slot];
+					values[slot] = value;
+					return oldValue;
+				}
 				return values[slot];
 			}
 			finally {

src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/OpenCustomHashMap.template

@@ -270,6 +270,11 @@ public class CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VAL
 			insert(-slot-1, key, value);
 			return getDefaultReturnValue();
 		}
+		else if(VALUE_EQUALS(values[slot], getDefaultReturnValue())) {
+			VALUE_TYPE oldValue = values[slot];
+			values[slot] = value;
+			return oldValue;
+		}
 		return values[slot];
 	}
 	

src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/OpenHashMap.template

@@ -245,6 +245,11 @@ public class HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENE
 			insert(-slot-1, key, value);
 			return getDefaultReturnValue();
 		}
+		else if(VALUE_EQUALS(values[slot], getDefaultReturnValue())) {
+			VALUE_TYPE oldValue = values[slot];
+			values[slot] = value;
+			return oldValue;
+		}
 		return values[slot];
 	}
 	

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template

@@ -202,6 +202,11 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
 			insertIndex(size++, key, value);
 			return getDefaultReturnValue();
 		}
+		else if(VALUE_EQUALS(values[index], getDefaultReturnValue())) {
+			VALUE_TYPE oldValue = values[index];
+			values[index] = value;
+			return oldValue;
+		}
 		return values[index];
 	}
 	

src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/EnumMap.template

@@ -161,7 +161,14 @@ public class ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE
 	@Override
 	public VALUE_TYPE putIfAbsent(T key, VALUE_TYPE value) {
 		int index = key.ordinal();
-		if(isSet(index)) return values[index];
+		if(isSet(index)) {
+			if(VALUE_EQUALS(values[index], getDefaultReturnValue())) {
+				VALUE_TYPE oldValue = values[index];
+				values[index] = value;
+				return oldValue;
+			}
+			return values[index];
+		}
 		set(index);
 		values[index] = value;
 		return getDefaultReturnValue();

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/AVLTreeMap.template

@@ -280,7 +280,10 @@ public class AVL_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_
 		int compare = 0;
 		Node KEY_VALUE_GENERIC_TYPE parent = tree;
 		while(true) {
-			if((compare = compare(key, parent.key)) == 0) return parent.value;
+			if((compare = compare(key, parent.key)) == 0) {
+				if(VALUE_EQUALS(parent.value, getDefaultReturnValue())) return parent.setValue(value);
+				return parent.value;
+			}
 			if(compare < 0) {
 				if(parent.left == null) break;
 				parent = parent.left;

src/builder/resources/speiger/assets/collections/templates/maps/impl/tree/RBTreeMap.template

@@ -280,7 +280,10 @@ public class RB_TREE_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_G
 		int compare = 0;
 		Node KEY_VALUE_GENERIC_TYPE parent = tree;
 		while(true) {
-			if((compare = compare(key, parent.key)) == 0) return parent.value;
+			if((compare = compare(key, parent.key)) == 0) {
+				if(VALUE_EQUALS(parent.value, getDefaultReturnValue())) return parent.setValue(value);
+				return parent.value;
+			}
 			if(compare < 0) {
 				if(parent.left == null) break;
 				parent = parent.left;

src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template

@@ -102,6 +102,26 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
 	 */
 	public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value);
 	
+	/**
+	 * A Helper method that allows to put int a MAP.Entry into a map.
+	 * @param entry then Entry that should be inserted.
+	 * @return the last present value or default return value.
+	 */
+	public default VALUE_TYPE put(Entry KEY_VALUE_GENERIC_TYPE entry) {
+		return put(entry.ENTRY_KEY(), entry.ENTRY_VALUE());
+	}
+	
+#if !TYPE_OBJECT || !VALUE_OBJECT
+	/**
+	 * A Helper method that allows to put int a Map.Entry into a map.
+	 * @param entry then Entry that should be inserted.
+	 * @return the last present value or default return	value.
+	 */
+	public default CLASS_VALUE_TYPE put(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) {
+		return put(entry.getKey(), entry.getValue());
+	}
+
+#endif
 	/**
 	 * Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
 	 * @param keys the keys that should be added

src/builder/resources/speiger/assets/collections/templates/utils/AsyncBuilder.template

@@ -173,6 +173,16 @@ public class ASYNC_BUILDER KEY_GENERIC_TYPE
 		return this;
 	}
 	
+	/**
+	 * Repeats the elements inside of the Iterable
+	 * @param repeats the amount of times the elements should be repeated
+	 * @return self with a repeater applied
+	 */
+	public ASYNC_BUILDER KEY_GENERIC_TYPE repeat(int repeats) {
+		iterable = ITERABLES.repeat(iterable, repeats);
+		return this;
+	}
+	
 	/**
 	 * Limits how many elements are inside of the Iterable
 	 * @param limit how many elements should max be iterated through

src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template

@@ -25,6 +25,7 @@ import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
 import speiger.src.collections.PACKAGE.sets.HASH_SET;
 import speiger.src.collections.PACKAGE.sets.SET;
 #endif
+import speiger.src.collections.utils.ISizeProvider;
 
 /**
  * A Helper class for Iterables
@@ -147,6 +148,28 @@ public class ITERABLES
 		return new DistinctIterableBRACES(wrap(iterable));
 	}
 	
+	/**
+	 * A Helper function that repeats the Iterable a specific amount of times
+	 * @param iterable that should be repeated
+	 * @param repeats the amount of times the iterable should be repeated
+	 * @Type(T)
+	 * @return a repeating iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE repeat(ITERABLE KEY_GENERIC_TYPE iterable, int repeats) {
+		return new RepeatingIterableBRACES(iterable, repeats);
+	}
+	
+	/**
+	 * A Helper function that repeats the Iterable a specific amount of times from a Java Iterable
+	 * @param iterable that should be repeated
+	 * @param repeats the amount of times the iterable should be repeated
+	 * @Type(T)
+	 * @return a repeating iterable
+	 */
+	public static GENERIC_KEY_BRACES ITERABLE KEY_GENERIC_TYPE repeat(Iterable<? extends CLASS_TYPE> iterable, int repeats) {
+		return new RepeatingIterableBRACES(wrap(iterable), repeats);
+	}
+	
 	/**
 	 * A Helper function that hard limits the Iterable to a specific size
 	 * @param iterable that should be limited
@@ -225,7 +248,7 @@ public class ITERABLES
 		return new WrappedIterableBRACES(iterable);
 	}
 	
-	private static class WrappedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	private static class WrappedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE, ISizeProvider
 	{
 		Iterable<? extends CLASS_TYPE> iterable;
 		
@@ -237,6 +260,12 @@ public class ITERABLES
 			return ITERATORS.wrap(iterable.iterator());
 		}
 		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			return prov == null ? -1 : prov.size();
+		}
+		
 #if !TYPE_OBJECT
 		@Override
 		public void forEach(CONSUMER action) {
@@ -251,7 +280,7 @@ public class ITERABLES
 #endif
 	}
 	
-	private static class MappedIterable KSS_GENERIC_TYPE<E, T> implements ObjectIterable<T>
+	private static class MappedIterable KSS_GENERIC_TYPE<E, T> implements ObjectIterable<T>, ISizeProvider
 	{
 		ITERABLE KEY_SPECIAL_GENERIC_TYPE<E> iterable;
 		TO_OBJECT_FUNCTION KSS_GENERIC_TYPE<E, T> mapper;
@@ -265,6 +294,12 @@ public class ITERABLES
 			return ITERATORS.map(iterable.iterator(), mapper);
 		}
 		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(this);
+			return prov == null ? -1 : prov.size();
+		}
+		
 		@Override
 		public void forEach(Consumer<? super T> action) {
 			Objects.requireNonNull(action);
@@ -320,6 +355,48 @@ public class ITERABLES
 		}
 	}
 	
+	private static class RepeatingIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE, ISizeProvider
+	{
+		ITERABLE KEY_GENERIC_TYPE iterable;
+		int repeats;
+		
+		public RepeatingIterable(ITERABLE KEY_GENERIC_TYPE iterable, int repeats) {
+			this.iterable = iterable;
+			this.repeats = repeats;
+		}
+		
+		@Override
+		public ITERATOR KEY_GENERIC_TYPE iterator() {
+			return ITERATORS.repeat(iterable.iterator(), repeats);
+		}
+		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			return prov == null ? -1 : prov.size() * (repeats+1);
+		}
+		
+#if !TYPE_OBJECT
+		@Override
+		public void forEach(CONSUMER action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(action.andThen(list::add));
+			for(int i = 0;i<repeats;i++)
+				list.forEach(action);
+		}
+#else
+		@Override
+		public void forEach(Consumer<? super CLASS_TYPE> action) {
+			Objects.requireNonNull(action);
+			LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+			iterable.forEach(T -> {action.accept(T); list.add(T);});
+			for(int i = 0;i<repeats;i++)
+				list.forEach(action);
+		}
+#endif
+	}
+	
 	private static class FilteredIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;
@@ -349,7 +426,7 @@ public class ITERABLES
 #endif
 	}
 	
-	private static class LimitedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	private static class LimitedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE, ISizeProvider
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;
 		long limit;
@@ -364,6 +441,12 @@ public class ITERABLES
 			return ITERATORS.limit(iterable.iterator(), limit);
 		}
 		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			return prov == null ? -1 : (int)Math.min(prov.size(), limit);
+		}
+		
 #if !TYPE_OBJECT
 		@Override
 		public void forEach(CONSUMER action) {
@@ -388,7 +471,7 @@ public class ITERABLES
 #endif
 	}
 	
-	private static class SortedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	private static class SortedIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE, ISizeProvider
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;
 		COMPARATOR KEY_GENERIC_TYPE sorter;
@@ -403,6 +486,12 @@ public class ITERABLES
 			return ITERATORS.sorted(iterable.iterator(), sorter);
 		}
 		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			return prov == null ? -1 : prov.size();
+		}
+		
 #if !TYPE_OBJECT
 		@Override
 		public void forEach(CONSUMER action) {
@@ -462,7 +551,7 @@ public class ITERABLES
 #endif
 	}
 	
-	private static class PeekIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE
+	private static class PeekIterable KEY_GENERIC_TYPE implements ITERABLE KEY_GENERIC_TYPE, ISizeProvider
 	{
 		ITERABLE KEY_GENERIC_TYPE iterable;
 		CONSUMER KEY_GENERIC_TYPE action;
@@ -477,6 +566,12 @@ public class ITERABLES
 			return ITERATORS.peek(iterable.iterator(), action);
 		}
 		
+		@Override
+		public int size() {
+			ISizeProvider prov = ISizeProvider.of(iterable);
+			return prov == null ? -1 : prov.size();
+		}
+		
 #if !TYPE_OBJECT
 		@Override
 		public void forEach(CONSUMER action) {

src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template

@@ -215,6 +215,28 @@ public class ITERATORS
 		return new DistinctIteratorBRACES(wrap(iterator));
 	}
 	
+	/**
+	 * A Helper function that repeats the Iterator a specific amount of times
+	 * @param iterator that should be repeated
+	 * @param repeats the amount of times the iterator should be repeated
+	 * @Type(T)
+	 * @return a repeating iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE repeat(ITERATOR KEY_GENERIC_TYPE iterator, int repeats) {
+		return new RepeatingIteratorBRACES(iterator, repeats);
+	}
+	
+	/**
+	 * A Helper function that repeats the Iterator a specific amount of times from a Java Iterator
+	 * @param iterator that should be repeated
+	 * @param repeats the amount of times the iterator should be repeated
+	 * @Type(T)
+	 * @return a repeating iterator
+	 */
+	public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE repeat(Iterator<? extends CLASS_TYPE> iterator, int repeats) {
+		return new RepeatingIteratorBRACES(wrap(iterator), repeats);
+	}
+	
 	/**
 	 * A Helper function that hard limits the Iterator to a specific size
 	 * @param iterator that should be limited
@@ -898,6 +920,38 @@ public class ITERATORS
 		}
 	}
 	
+	private static class RepeatingIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
+	{
+		final int repeats;
+		int index = 0;
+		ITERATOR KEY_GENERIC_TYPE iter;
+		LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES();
+		
+		public RepeatingIterator(ITERATOR KEY_GENERIC_TYPE iter, int repeat) {
+			this.iter = iter;
+			this.repeats = repeat;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			if(iter.hasNext()) return true;
+			if(index < repeats) {
+				index++;
+				iter = list.iterator();
+				return iter.hasNext();
+			}
+			return false;
+		}
+
+		@Override
+		public KEY_TYPE NEXT() {
+			if(!hasNext()) throw new NoSuchElementException();
+			KEY_TYPE value = iter.NEXT();
+			if(index == 0) list.add(value);
+			return value;
+		}
+	}
+	
 	private static class SortedIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
 	{
 		ITERATOR KEY_GENERIC_TYPE iterator;

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

@@ -0,0 +1,93 @@
+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_TYPEIterableRepeatTester;
+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_TYPEIterableRepeatTester.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);
+	}
+}