Speiger
/
Primitive-Collections
0
0
Fork 1
Code Issues 1 Pull Requests Projects Releases 1 Wiki Activity

Refactor of the Project on Github. 

-Added: Better System to decide what code should be generated.
-Added: Unit Tests are now included in the main branch.
-Added: Automatic System to test the main branch and ensure that tests work.
-Added: Pull Requests now run tests too.
This commit is contained in:
Speiger 2022-06-14 08:55:40 +02:00
parent ddc58ee221
commit fb7c417394
186 changed files with 19991 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
.github/workflows/build_action.yml vendored Normal file
View File

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

84
.github/workflows/build_tests_action.yml vendored Normal file
View File

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

36
.github/workflows/build_validator.yml vendored
View File

@ -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

39
.github/workflows/pull_build_tests_action.yml vendored Normal file
View File

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

14
.gitignore vendored
View File

@ -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

159
build.gradle
View File

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

27
src/builder/java/speiger/src/builder/ClassType.java
View File

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

90
src/builder/java/speiger/src/builder/GlobalVariables.java
View File

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

117
src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java
View File

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

91
src/builder/resources/speiger/assets/testers/templates/builder/CollectionTestSuiteBuilder.template Normal file
View File

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

28
src/builder/resources/speiger/assets/testers/templates/builder/DequeueTestSuiteBuilder.template Normal file
View File

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

384
src/builder/resources/speiger/assets/testers/templates/builder/ListTestSuiteBuilder.template Normal file
View File

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

140
src/builder/resources/speiger/assets/testers/templates/builder/NavigableSetTestSuiteBuilder.template Normal file
View File

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

38
src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template Normal file
View File

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

60
src/builder/resources/speiger/assets/testers/templates/builder/QueueTestSuiteBuilder.template Normal file
View File

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

116
src/builder/resources/speiger/assets/testers/templates/builder/SetTestSuiteBuilder.template Normal file
View File

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

88
src/builder/resources/speiger/assets/testers/templates/builder/SortedSetTestSuiteBuilder.template Normal file
View File

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

304
src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template Normal file
View File

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

79
src/builder/resources/speiger/assets/testers/templates/builder/maps/NavigableMapTestSuiteBuilder.template Normal file
View File

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

55
src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template Normal file
View File

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

90
src/builder/resources/speiger/assets/testers/templates/builder/maps/SortedMapTestSuiteBuilder.template Normal file
View File

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

30
src/builder/resources/speiger/assets/testers/templates/generators/TestCollectionGenerator.template Normal file
View File

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

16
src/builder/resources/speiger/assets/testers/templates/generators/TestListGenerator.template Normal file
View File

@ -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
}

13
src/builder/resources/speiger/assets/testers/templates/generators/TestNavigableSetGenerator.template Normal file
View File

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

13
src/builder/resources/speiger/assets/testers/templates/generators/TestOrderedSetGenerator.template Normal file
View File

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

30
src/builder/resources/speiger/assets/testers/templates/generators/TestQueueGenerator.template Normal file
View File

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

15
src/builder/resources/speiger/assets/testers/templates/generators/TestSetGenerator.template Normal file
View File

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

38
src/builder/resources/speiger/assets/testers/templates/generators/TestSortedSetGenerator.template Normal file
View File

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

46
src/builder/resources/speiger/assets/testers/templates/generators/maps/TestMapGenerator.template Normal file
View File

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

13
src/builder/resources/speiger/assets/testers/templates/generators/maps/TestOrderedMapGenerator.template Normal file
View File

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

25
src/builder/resources/speiger/assets/testers/templates/generators/maps/TestSortedMapGenerator.template Normal file
View File

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

314
src/builder/resources/speiger/assets/testers/templates/impl/CollectionConstructorTests.template Normal file
View File

@ -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
}

82
src/builder/resources/speiger/assets/testers/templates/impl/SimpleQueueTestGenerator.template Normal file
View File

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

221
src/builder/resources/speiger/assets/testers/templates/impl/SimpleTestGenerator.template Normal file
View File

@ -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
}

173
src/builder/resources/speiger/assets/testers/templates/impl/SortedSetSubsetTestSetGenerator.template Normal file
View File

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

550
src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template Normal file
View File

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

934
src/builder/resources/speiger/assets/testers/templates/impl/maps/MapConstructorTests.template Normal file
View File

@ -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
}

200
src/builder/resources/speiger/assets/testers/templates/impl/maps/SimpleMapTestGenerator.template Normal file
View File

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

92
src/builder/resources/speiger/assets/testers/templates/impl/maps/TestMap.template Normal file
View File

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

28
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractCollectionTester.template Normal file
View File

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

188
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractContainerTester.template Normal file
View File

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

27
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractListIndexOfTester.template Normal file
View File

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

39
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractListTester.template Normal file
View File

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

81
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractQueueTester.template Normal file
View File

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

14
src/builder/resources/speiger/assets/testers/templates/tests/base/AbstractSetTester.template Normal file
View File

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

243
src/builder/resources/speiger/assets/testers/templates/tests/base/maps/AbstractMapTester.template Normal file
View File

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

151
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddAllArrayTester.template Normal file
View File

@ -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
}

102
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddAllTester.template Normal file
View File

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

64
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionAddTester.template Normal file
View File

@ -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
}
}
}

68
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionClearTester.template Normal file
View File

@ -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
}
}
}

165
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionConstructorTester.template Normal file
View File

@ -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
}

45
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsAllTester.template Normal file
View File

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

42
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsAnyTester.template Normal file
View File

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

27
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionContainsTester.template Normal file
View File

@ -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
}

38
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionCopyTester.template Normal file
View File

@ -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
}
}
}

24
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionEqualsTester.template Normal file
View File

@ -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?"));
}
}

55
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionForEachTester.template Normal file
View File

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

161
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionIteratorTester.template Normal file
View File

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

153
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRemoveAllTester.template Normal file
View File

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

119
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRemoveIfTester.template Normal file
View File

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

337
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionRetainAllTester.template Normal file
View File

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

59
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionStreamTester.template Normal file
View File

@ -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
}

116
src/builder/resources/speiger/assets/testers/templates/tests/collection/CollectionToArrayTester.template Normal file
View File

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

47
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableCountTester.template Normal file
View File

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

24
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableDistinctTester.template Normal file
View File

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

52
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableFilterTester.template Normal file
View File

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

43
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableFindFirstTester.template Normal file
View File

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

25
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableLimitTester.template Normal file
View File

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

132
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableMapTester.template Normal file
View File

@ -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
}

107
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableMatchesTester.template Normal file
View File

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

19
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterablePeekTester.template Normal file
View File

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

78
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableReduceTester.template Normal file
View File

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

43
src/builder/resources/speiger/assets/testers/templates/tests/iterable/IterableSortedTester.template Normal file
View File

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

60
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAbsentTester.template Normal file
View File

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

194
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllArrayAtIndexTester.template Normal file
View File

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

167
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllAtIndexTester.template Normal file
View File

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

155
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllListAtIndexTester.template Normal file
View File

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

115
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAllTester.template Normal file
View File

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

112
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddAtIndexTester.template Normal file
View File

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

37
src/builder/resources/speiger/assets/testers/templates/tests/list/ListAddTester.template Normal file
View File

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

30
src/builder/resources/speiger/assets/testers/templates/tests/list/ListCreationTester.template Normal file
View File

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

45
src/builder/resources/speiger/assets/testers/templates/tests/list/ListEqualsTester.template Normal file
View File

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

86
src/builder/resources/speiger/assets/testers/templates/tests/list/ListExtractElementsTester.template Normal file
View File

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

23
src/builder/resources/speiger/assets/testers/templates/tests/list/ListFillBufferTester.template Normal file
View File

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

90
src/builder/resources/speiger/assets/testers/templates/tests/list/ListGetElementsTester.template Normal file
View File

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

35
src/builder/resources/speiger/assets/testers/templates/tests/list/ListGetTester.template Normal file
View File

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

40
src/builder/resources/speiger/assets/testers/templates/tests/list/ListIndexOfTester.template Normal file
View File

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

40
src/builder/resources/speiger/assets/testers/templates/tests/list/ListLastIndexOfTester.template Normal file
View File

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

73
src/builder/resources/speiger/assets/testers/templates/tests/list/ListListIteratorTester.template Normal file
View File

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

54
src/builder/resources/speiger/assets/testers/templates/tests/list/ListPresentTester.template Normal file
View File

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

32
src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveAllTester.template Normal file
View File

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

106
src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveAtIndexTester.template Normal file
View File

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

59
src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveElementsTester.template Normal file
View File

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

40
src/builder/resources/speiger/assets/testers/templates/tests/list/ListRemoveTester.template Normal file
View File

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

72
src/builder/resources/speiger/assets/testers/templates/tests/list/ListReplaceAllTester.template Normal file
View File

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

59
src/builder/resources/speiger/assets/testers/templates/tests/list/ListRetainAllTester.template Normal file
View File

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

83
src/builder/resources/speiger/assets/testers/templates/tests/list/ListSetTester.template Normal file
View File

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

102
src/builder/resources/speiger/assets/testers/templates/tests/list/ListSortTester.template Normal file
View File

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

309
src/builder/resources/speiger/assets/testers/templates/tests/list/ListSubListTester.template Normal file
View File

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

115
src/builder/resources/speiger/assets/testers/templates/tests/list/ListSwapRemoveAtIndexTester.template Normal file
View File

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

Some files were not shown because too many files have changed in this diff Show More