Small Fixes to doc and Useless Imports
This commit is contained in:
@@ -1,270 +1,270 @@
|
||||
package speiger.src.builder;
|
||||
|
||||
import java.io.BufferedWriter;
|
||||
import java.io.IOException;
|
||||
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.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.StringJoiner;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import speiger.src.builder.modules.AsyncModule;
|
||||
import speiger.src.builder.modules.BaseModule;
|
||||
import speiger.src.builder.modules.CollectionModule;
|
||||
import speiger.src.builder.modules.FunctionModule;
|
||||
import speiger.src.builder.modules.JavaModule;
|
||||
import speiger.src.builder.modules.ListModule;
|
||||
import speiger.src.builder.modules.MapModule;
|
||||
import speiger.src.builder.modules.PairModule;
|
||||
import speiger.src.builder.modules.PrioQueueModule;
|
||||
import speiger.src.builder.modules.SetModule;
|
||||
import speiger.src.builder.processor.TemplateProcess;
|
||||
import speiger.src.builder.processor.TemplateProcessor;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class PrimitiveCollectionsBuilder extends TemplateProcessor
|
||||
{
|
||||
private static final int SPECIAL = 0x1; //Detects if the Builder is generating tests
|
||||
private static final int LOAD = 0x2; //If Configs should be loaded
|
||||
private static final int ANTI_SAVE = SPECIAL | LOAD; //If save should be disabled since load/save shouldn't happen at the same time.
|
||||
private static final int SAVE = 0x4; //if the configuration should be created
|
||||
Set<String> globalFlags = new HashSet<>();
|
||||
List<ModulePackage> simplePackages = new ArrayList<>();
|
||||
List<ModulePackage> biPackages = new ArrayList<>();
|
||||
List<ModulePackage> enumPackages = new ArrayList<>();
|
||||
Map<String, RequiredType> requirements = new HashMap<>();
|
||||
SettingsManager manager = new SettingsManager();
|
||||
int flags;
|
||||
|
||||
public PrimitiveCollectionsBuilder()
|
||||
{
|
||||
this(false);
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(boolean silencedSuccess)
|
||||
{
|
||||
super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder)
|
||||
{
|
||||
this(false, sourceFolder, outputFolder, dataFolder);
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder)
|
||||
{
|
||||
super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
|
||||
}
|
||||
|
||||
private PrimitiveCollectionsBuilder setFlags(int flags) {
|
||||
this.flags = flags;
|
||||
if((flags & ANTI_SAVE) != 0) {
|
||||
this.flags &= ~SAVE;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private static PrimitiveCollectionsBuilder createTests(boolean silent, int flags) {
|
||||
return new PrimitiveCollectionsBuilder(silent,
|
||||
Paths.get("src/builder/resources/speiger/assets/tests/templates/"),
|
||||
Paths.get("src/test/java/speiger/src/tests/"),
|
||||
Paths.get("src/builder/resources/speiger/assets/tests/")).setFlags(flags | SPECIAL);
|
||||
}
|
||||
|
||||
private static PrimitiveCollectionsBuilder createTesters(boolean silent, int flags) {
|
||||
return new PrimitiveCollectionsBuilder(silent,
|
||||
Paths.get("src/builder/resources/speiger/assets/testers/templates/"),
|
||||
Paths.get("src/test/java/speiger/src/testers/"),
|
||||
Paths.get("src/builder/resources/speiger/assets/testers/")).setFlags(flags | SPECIAL);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean isFileValid(Path fileName)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean relativePackages()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean debugUnusedMappers()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void afterFinish()
|
||||
{
|
||||
if((flags & SPECIAL) == 0 && getVersion() > 8)
|
||||
{
|
||||
Path basePath = Paths.get("src/main/java");
|
||||
try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
|
||||
{
|
||||
writer.write(getModuleInfo(basePath));
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public List<BaseModule> createModules()
|
||||
{
|
||||
List<BaseModule> modules = new ArrayList<>();
|
||||
modules.add(JavaModule.INSTANCE);
|
||||
modules.add(FunctionModule.INSTANCE);
|
||||
modules.add(CollectionModule.INSTANCE);
|
||||
modules.add(PrioQueueModule.INSTANCE);
|
||||
modules.add(ListModule.INSTANCE);
|
||||
modules.add(SetModule.INSTANCE);
|
||||
modules.add(MapModule.INSTANCE);
|
||||
modules.add(PairModule.INSTANCE);
|
||||
modules.add(AsyncModule.INSTANCE);
|
||||
return modules;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
protected void init()
|
||||
{
|
||||
prepPackages();
|
||||
//Init Modules here
|
||||
addModules(createModules());
|
||||
finishPackages();
|
||||
}
|
||||
|
||||
public void addModules(List<BaseModule> modules)
|
||||
{
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
modules.get(i).setManager(manager);
|
||||
}
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
biPackages.forEach(modules.get(i)::init);
|
||||
}
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
modules.get(i).cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
private void finishPackages()
|
||||
{
|
||||
biPackages.forEach(ModulePackage::finish);
|
||||
if((flags & SAVE) != 0) manager.save();
|
||||
}
|
||||
|
||||
private void prepPackages()
|
||||
{
|
||||
if((flags & LOAD) != 0) manager.load();
|
||||
for(ModulePackage entry : ModulePackage.createPackages(globalFlags))
|
||||
{
|
||||
entry.setRequirements(requirements::put);
|
||||
biPackages.add(entry);
|
||||
if(entry.isSame()) simplePackages.add(entry);
|
||||
if(entry.isEnumValid()) enumPackages.add(entry);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createProcesses(String fileName, Consumer<TemplateProcess> process)
|
||||
{
|
||||
List<ModulePackage> packages = getPackagesByRequirement(requirements.get(fileName));
|
||||
for(int i = 0,m=packages.size();i<m;i++)
|
||||
{
|
||||
packages.get(i).process(fileName, process);
|
||||
}
|
||||
}
|
||||
|
||||
protected List<ModulePackage> getPackagesByRequirement(RequiredType type) {
|
||||
if(type == null) return simplePackages;
|
||||
if(type == RequiredType.BI_CLASS) return biPackages;
|
||||
if(type == RequiredType.ENUM) return enumPackages;
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
private String getModuleInfo(Path basePath) {
|
||||
StringJoiner joiner = new StringJoiner("\n", "", "\n");
|
||||
try(Stream<Path> stream = Files.walk(getOutputFolder()))
|
||||
{
|
||||
stream.filter(Files::isDirectory)
|
||||
.filter(this::containsFiles)
|
||||
.map(basePath::relativize)
|
||||
.map(Path::toString)
|
||||
.map(this::sanitize)
|
||||
.forEach(T -> joiner.add("\texports "+T+";"));
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
StringBuilder builder = new StringBuilder();
|
||||
builder.append("/** @author Speiger */\n");
|
||||
builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
|
||||
builder.append(joiner.toString()).append("}");
|
||||
return builder.toString();
|
||||
}
|
||||
|
||||
private String sanitize(String input)
|
||||
{
|
||||
return input.replace("\\", ".").replace("/", ".");
|
||||
}
|
||||
|
||||
private boolean containsFiles(Path path)
|
||||
{
|
||||
try(Stream<Path> stream = Files.walk(path, 1))
|
||||
{
|
||||
return stream.filter(Files::isRegularFile).findFirst().isPresent();
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private int getVersion()
|
||||
{
|
||||
String version = System.getProperty("java.version");
|
||||
if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
|
||||
int dot = version.indexOf(".");
|
||||
return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
|
||||
}
|
||||
|
||||
public static void main(String...args)
|
||||
{
|
||||
try
|
||||
{
|
||||
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");
|
||||
boolean load = flags.contains("load");
|
||||
boolean save = flags.contains("save");
|
||||
int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
|
||||
new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
|
||||
if(tests) {
|
||||
createTests(silent, flag).process(force || forceTests);
|
||||
createTesters(silent, flag).process(force || forceTests);
|
||||
}
|
||||
}
|
||||
catch(InterruptedException | IOException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
package speiger.src.builder;
|
||||
|
||||
import java.io.BufferedWriter;
|
||||
import java.io.IOException;
|
||||
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.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.StringJoiner;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import speiger.src.builder.modules.AsyncModule;
|
||||
import speiger.src.builder.modules.BaseModule;
|
||||
import speiger.src.builder.modules.CollectionModule;
|
||||
import speiger.src.builder.modules.FunctionModule;
|
||||
import speiger.src.builder.modules.JavaModule;
|
||||
import speiger.src.builder.modules.ListModule;
|
||||
import speiger.src.builder.modules.MapModule;
|
||||
import speiger.src.builder.modules.PairModule;
|
||||
import speiger.src.builder.modules.PrioQueueModule;
|
||||
import speiger.src.builder.modules.SetModule;
|
||||
import speiger.src.builder.processor.TemplateProcess;
|
||||
import speiger.src.builder.processor.TemplateProcessor;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class PrimitiveCollectionsBuilder extends TemplateProcessor
|
||||
{
|
||||
private static final int SPECIAL = 0x1; //Detects if the Builder is generating tests
|
||||
private static final int LOAD = 0x2; //If Configs should be loaded
|
||||
private static final int ANTI_SAVE = SPECIAL | LOAD; //If save should be disabled since load/save shouldn't happen at the same time.
|
||||
private static final int SAVE = 0x4; //if the configuration should be created
|
||||
Set<String> globalFlags = new HashSet<>();
|
||||
List<ModulePackage> simplePackages = new ArrayList<>();
|
||||
List<ModulePackage> biPackages = new ArrayList<>();
|
||||
List<ModulePackage> enumPackages = new ArrayList<>();
|
||||
Map<String, RequiredType> requirements = new HashMap<>();
|
||||
SettingsManager manager = new SettingsManager();
|
||||
int flags;
|
||||
|
||||
public PrimitiveCollectionsBuilder()
|
||||
{
|
||||
this(false);
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(boolean silencedSuccess)
|
||||
{
|
||||
super(silencedSuccess, Paths.get("src/builder/resources/speiger/assets/collections/templates/"), Paths.get("src/main/java/speiger/src/collections/"), Paths.get("src/builder/resources/speiger/assets/collections/"));
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(Path sourceFolder, Path outputFolder, Path dataFolder)
|
||||
{
|
||||
this(false, sourceFolder, outputFolder, dataFolder);
|
||||
}
|
||||
|
||||
public PrimitiveCollectionsBuilder(boolean silencedSuccess, Path sourceFolder, Path outputFolder, Path dataFolder)
|
||||
{
|
||||
super(silencedSuccess, sourceFolder, outputFolder, dataFolder);
|
||||
}
|
||||
|
||||
private PrimitiveCollectionsBuilder setFlags(int flags) {
|
||||
this.flags = flags;
|
||||
if((flags & ANTI_SAVE) != 0) {
|
||||
this.flags &= ~SAVE;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private static PrimitiveCollectionsBuilder createTests(boolean silent, int flags) {
|
||||
return new PrimitiveCollectionsBuilder(silent,
|
||||
Paths.get("src/builder/resources/speiger/assets/tests/templates/"),
|
||||
Paths.get("src/test/java/speiger/src/tests/"),
|
||||
Paths.get("src/builder/resources/speiger/assets/tests/")).setFlags(flags | SPECIAL);
|
||||
}
|
||||
|
||||
private static PrimitiveCollectionsBuilder createTesters(boolean silent, int flags) {
|
||||
return new PrimitiveCollectionsBuilder(silent,
|
||||
Paths.get("src/builder/resources/speiger/assets/testers/templates/"),
|
||||
Paths.get("src/test/java/speiger/src/testers/"),
|
||||
Paths.get("src/builder/resources/speiger/assets/testers/")).setFlags(flags | SPECIAL);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean isFileValid(Path fileName)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean relativePackages()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean debugUnusedMappers()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void afterFinish()
|
||||
{
|
||||
if((flags & SPECIAL) == 0 && getVersion() > 8)
|
||||
{
|
||||
Path basePath = Paths.get("src/main/java");
|
||||
try(BufferedWriter writer = Files.newBufferedWriter(basePath.resolve("module-info.java")))
|
||||
{
|
||||
writer.write(getModuleInfo(basePath));
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public List<BaseModule> createModules()
|
||||
{
|
||||
List<BaseModule> modules = new ArrayList<>();
|
||||
modules.add(JavaModule.INSTANCE);
|
||||
modules.add(FunctionModule.INSTANCE);
|
||||
modules.add(CollectionModule.INSTANCE);
|
||||
modules.add(PrioQueueModule.INSTANCE);
|
||||
modules.add(ListModule.INSTANCE);
|
||||
modules.add(SetModule.INSTANCE);
|
||||
modules.add(MapModule.INSTANCE);
|
||||
modules.add(PairModule.INSTANCE);
|
||||
modules.add(AsyncModule.INSTANCE);
|
||||
return modules;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
protected void init()
|
||||
{
|
||||
prepPackages();
|
||||
//Init Modules here
|
||||
addModules(createModules());
|
||||
finishPackages();
|
||||
}
|
||||
|
||||
public void addModules(List<BaseModule> modules)
|
||||
{
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
modules.get(i).setManager(manager);
|
||||
}
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
biPackages.forEach(modules.get(i)::init);
|
||||
}
|
||||
for(int i = 0,m=modules.size();i<m;i++) {
|
||||
modules.get(i).cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
private void finishPackages()
|
||||
{
|
||||
biPackages.forEach(ModulePackage::finish);
|
||||
if((flags & SAVE) != 0) manager.save();
|
||||
}
|
||||
|
||||
private void prepPackages()
|
||||
{
|
||||
if((flags & LOAD) != 0) manager.load();
|
||||
for(ModulePackage entry : ModulePackage.createPackages(globalFlags))
|
||||
{
|
||||
entry.setRequirements(requirements::put);
|
||||
biPackages.add(entry);
|
||||
if(entry.isSame()) simplePackages.add(entry);
|
||||
if(entry.isEnumValid()) enumPackages.add(entry);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createProcesses(String fileName, Consumer<TemplateProcess> process)
|
||||
{
|
||||
List<ModulePackage> packages = getPackagesByRequirement(requirements.get(fileName));
|
||||
for(int i = 0,m=packages.size();i<m;i++)
|
||||
{
|
||||
packages.get(i).process(fileName, process);
|
||||
}
|
||||
}
|
||||
|
||||
protected List<ModulePackage> getPackagesByRequirement(RequiredType type) {
|
||||
if(type == null) return simplePackages;
|
||||
if(type == RequiredType.BI_CLASS) return biPackages;
|
||||
if(type == RequiredType.ENUM) return enumPackages;
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
private String getModuleInfo(Path basePath) {
|
||||
StringJoiner joiner = new StringJoiner("\n", "", "\n");
|
||||
try(Stream<Path> stream = Files.walk(getOutputFolder()))
|
||||
{
|
||||
stream.filter(Files::isDirectory)
|
||||
.filter(this::containsFiles)
|
||||
.map(basePath::relativize)
|
||||
.map(Path::toString)
|
||||
.map(this::sanitize)
|
||||
.forEach(T -> joiner.add("\texports "+T+";"));
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
StringBuilder builder = new StringBuilder();
|
||||
builder.append("/** @author Speiger */\n");
|
||||
builder.append("module ").append(sanitize(basePath.relativize(getOutputFolder()).toString())).append(" {\n");
|
||||
builder.append(joiner.toString()).append("}");
|
||||
return builder.toString();
|
||||
}
|
||||
|
||||
private String sanitize(String input)
|
||||
{
|
||||
return input.replace("\\", ".").replace("/", ".");
|
||||
}
|
||||
|
||||
private boolean containsFiles(Path path)
|
||||
{
|
||||
try(Stream<Path> stream = Files.walk(path, 1))
|
||||
{
|
||||
return stream.filter(Files::isRegularFile).findFirst().isPresent();
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private int getVersion()
|
||||
{
|
||||
String version = System.getProperty("java.version");
|
||||
if(version.startsWith("1.")) return Integer.parseInt(version.substring(2, 3));
|
||||
int dot = version.indexOf(".");
|
||||
return Integer.parseInt(dot != -1 ? version.substring(0, dot) : version);
|
||||
}
|
||||
|
||||
public static void main(String...args)
|
||||
{
|
||||
try
|
||||
{
|
||||
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");
|
||||
boolean load = flags.contains("load");
|
||||
boolean save = flags.contains("save");
|
||||
int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
|
||||
new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
|
||||
if(tests) {
|
||||
createTests(silent, flag).process(force || forceTests);
|
||||
createTesters(silent, flag).process(force || forceTests);
|
||||
}
|
||||
}
|
||||
catch(InterruptedException | IOException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,281 +1,281 @@
|
||||
package speiger.src.builder.modules;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Set;
|
||||
import java.util.TreeSet;
|
||||
|
||||
import speiger.src.builder.ClassType;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class MapModule extends BaseModule
|
||||
{
|
||||
public static final BaseModule INSTANCE = new MapModule();
|
||||
|
||||
@Override
|
||||
public String getModuleName() { return "Map"; }
|
||||
@Override
|
||||
public boolean isBiModule() { return true; }
|
||||
@Override
|
||||
protected void loadVariables() {}
|
||||
@Override
|
||||
public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; }
|
||||
@Override
|
||||
public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); }
|
||||
|
||||
@Override
|
||||
public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
|
||||
Set<String> sets = new TreeSet<>();
|
||||
sets.addAll(Arrays.asList("Wrappers", "Implementations"));
|
||||
sets.addAll(Arrays.asList("OrderedMap", "SortedMap"));
|
||||
sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap"));
|
||||
sets.addAll(Arrays.asList("HashMap", "LinkedHashMap"));
|
||||
sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap"));
|
||||
sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap"));
|
||||
sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap"));
|
||||
return sets;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadFlags()
|
||||
{
|
||||
if(isModuleEnabled()) addFlag("MAP_MODULE");
|
||||
if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE");
|
||||
boolean implementations = isModuleEnabled("Implementations");
|
||||
boolean hashMap = implementations && isModuleEnabled("HashMap");
|
||||
boolean customHashMap = implementations && isModuleEnabled("CustomHashMap");
|
||||
boolean enumMap = implementations && isModuleEnabled("EnumMap");
|
||||
|
||||
if(isModuleEnabled("OrderedMap")) {
|
||||
addFlag("ORDERED_MAP_FEATURE");
|
||||
if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE");
|
||||
if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE");
|
||||
if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE");
|
||||
if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE");
|
||||
}
|
||||
if(isModuleEnabled("SortedMap")) {
|
||||
addFlag("SORTED_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE");
|
||||
}
|
||||
if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE");
|
||||
if(hashMap) addFlag("MAP_FEATURE");
|
||||
if(customHashMap) addFlag("CUSTOM_MAP_FEATURE");
|
||||
if(enumMap) addFlag("ENUM_MAP_FEATURE");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadBlockades()
|
||||
{
|
||||
if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap");
|
||||
if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps");
|
||||
boolean implementations = !isModuleEnabled("Implementations");
|
||||
if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap");
|
||||
if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
|
||||
|
||||
boolean ordered = !isModuleEnabled("OrderedMap");
|
||||
if(ordered) addBlockedFiles("OrderedMap");
|
||||
boolean hashMap = implementations || !isModuleEnabled("HashMap");
|
||||
if(hashMap) addBlockedFiles("OpenHashMap");
|
||||
if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap");
|
||||
|
||||
boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap");
|
||||
if(customHashMap) addBlockedFiles("OpenCustomHashMap");
|
||||
if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap");
|
||||
|
||||
boolean enumMap = implementations || !isModuleEnabled("EnumMap");
|
||||
if(enumMap) addBlockedFiles("EnumMap");
|
||||
if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap");
|
||||
|
||||
if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap");
|
||||
|
||||
boolean sorted = !isModuleEnabled("SortedMap");
|
||||
if(sorted) addBlockedFiles("SortedMap", "NavigableMap");
|
||||
if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap");
|
||||
if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap");
|
||||
|
||||
if(keyType == ClassType.BOOLEAN)
|
||||
{
|
||||
//Main Classes
|
||||
addBlockedFiles("SortedMap", "NavigableMap", "RBTreeMap", "AVLTreeMap");
|
||||
addBlockedFiles("OrderedMap", "ArrayMap", "LinkedOpenHashMap", "LinkedOpenCustomHashMap");
|
||||
addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
|
||||
addBlockedFiles("Map", "Maps", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "OpenCustomHashMap");
|
||||
|
||||
//Test Classes
|
||||
addBlockedFiles("TestMap", "MapTests", "MapTestSuiteBuilder", "MapConstructorTests", "TestMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester");
|
||||
addBlockedFiles("TestSortedMapGenerator", "OrderedMapTestSuiteBuilder", "NavigableMapTestSuiteBuilder", "SortedMapTestSuiteBuilder");
|
||||
addBlockedFiles("TestOrderedMapGenerator");
|
||||
addBlockedFilter(T -> T.endsWith("Tester") && (T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadRemappers()
|
||||
{
|
||||
//Main Classes
|
||||
addBiRequirement("Map");
|
||||
addBiRequirement("SortedMap");
|
||||
addBiRequirement("OrderedMap");
|
||||
addBiRequirement("NavigableMap");
|
||||
addBiRequirement("ConcurrentMap");
|
||||
addBiRequirement("AbstractMap");
|
||||
addEnumRequirement("EnumMap");
|
||||
addEnumRequirement("LinkedEnumMap");
|
||||
addBiRequirement("ConcurrentOpenHashMap");
|
||||
addBiRequirement("ImmutableOpenHashMap");
|
||||
addBiRequirement("OpenHashMap");
|
||||
addBiRequirement("LinkedOpenHashMap");
|
||||
addBiRequirement("OpenCustomHashMap");
|
||||
addBiRequirement("LinkedOpenCustomHashMap");
|
||||
addBiRequirement("ArrayMap");
|
||||
addBiRequirement("RBTreeMap");
|
||||
addBiRequirement("AVLTreeMap");
|
||||
addBiRequirement("Maps");
|
||||
|
||||
addRemapper("AbstractMap", "Abstract%sMap");
|
||||
addRemapper("EnumMap", "Enum2%sMap");
|
||||
addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
|
||||
addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
|
||||
|
||||
//Test Classes
|
||||
addBiRequirement("TestMapGenerator");
|
||||
addBiRequirement("TestSortedMapGenerator");
|
||||
addBiRequirement("TestOrderedMapGenerator");
|
||||
addBiRequirement("SimpleMapTestGenerator");
|
||||
addBiRequirement("DerivedMapGenerators");
|
||||
addBiRequirement("AbstractMapTester");
|
||||
addBiRequirement("MapTestSuiteBuilder");
|
||||
addBiRequirement("SortedMapTestSuiteBuilder");
|
||||
addBiRequirement("NavigableMapTestSuiteBuilder");
|
||||
addBiRequirement("OrderedMapTestSuiteBuilder");
|
||||
addBiRequirement("MapTests");
|
||||
addBiRequirement("MapConstructorTests");
|
||||
addBiRequirement("TestMap");
|
||||
addBiRequirement("MapAddToTester");
|
||||
addBiRequirement("MapSubFromTester");
|
||||
addBiRequirement("MapClearTester");
|
||||
addBiRequirement("MapComputeIfAbsentTester");
|
||||
addBiRequirement("MapComputeIfPresentTester");
|
||||
addBiRequirement("MapComputeTester");
|
||||
addBiRequirement("MapCopyTester");
|
||||
addBiRequirement("MapContainsTester");
|
||||
addBiRequirement("MapContainsKeyTester");
|
||||
addBiRequirement("MapContainsValueTester");
|
||||
addBiRequirement("MapCreatorTester");
|
||||
addBiRequirement("MapEntrySetTester");
|
||||
addBiRequirement("MapEqualsTester");
|
||||
addBiRequirement("MapForEachTester");
|
||||
addBiRequirement("MapGetOrDefaultTester");
|
||||
addBiRequirement("MapGetTester");
|
||||
addBiRequirement("MapHashCodeTester");
|
||||
addBiRequirement("MapIsEmptyTester");
|
||||
addBiRequirement("MapMergeTester");
|
||||
addBiRequirement("MapMergeBulkTester");
|
||||
addBiRequirement("MapPutAllArrayTester");
|
||||
addBiRequirement("MapPutAllTester");
|
||||
addBiRequirement("MapPutIfAbsentTester");
|
||||
addBiRequirement("MapPutTester");
|
||||
addBiRequirement("MapRemoveEntryTester");
|
||||
addBiRequirement("MapRemoveOrDefaultTester");
|
||||
addBiRequirement("MapRemoveTester");
|
||||
addBiRequirement("MapReplaceAllTester");
|
||||
addBiRequirement("MapReplaceEntryTester");
|
||||
addBiRequirement("MapReplaceTester");
|
||||
addBiRequirement("MapSizeTester");
|
||||
addBiRequirement("MapSupplyIfAbsentTester");
|
||||
addBiRequirement("MapToStringTester");
|
||||
addBiRequirement("NavigableMapNavigationTester");
|
||||
addBiRequirement("SortedMapNavigationTester");
|
||||
addBiRequirement("OrderedMapNavigationTester");
|
||||
addBiRequirement("OrderedMapMoveTester");
|
||||
addBiRequirement("MapConstructorTester");
|
||||
|
||||
addRemapper("TestMapGenerator", "Test%sMapGenerator");
|
||||
addRemapper("TestSortedMapGenerator", "Test%sSortedMapGenerator");
|
||||
addRemapper("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
|
||||
addRemapper("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
|
||||
addRemapper("DerivedMapGenerators", "Derived%sMapGenerators");
|
||||
addRemapper("AbstractMapTester", "Abstract%sMapTester");
|
||||
addRemapper("TestMap", "Test%sMap");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadFunctions()
|
||||
{
|
||||
addFunctionValueMapper("BULK_MERGE", "mergeAll");
|
||||
addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
|
||||
addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
|
||||
addFunctionValueMapper("COMPUTE", "compute");
|
||||
addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
|
||||
addFunctionMapper("DEQUEUE", "dequeue");
|
||||
addSimpleMapper("ENTRY_SET", keyType.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
|
||||
addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
|
||||
addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
|
||||
if(keyType.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
|
||||
else addSimpleMapper("GET_VALUE", "get");
|
||||
addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
|
||||
addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
|
||||
addFunctionValueMapper("MERGE", "merge");
|
||||
addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
|
||||
addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
|
||||
if(keyType.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
|
||||
else addSimpleMapper("REMOVE_VALUE", "remove");
|
||||
addFunctionMapper("REMOVE", "remove");
|
||||
addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
|
||||
addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadClasses()
|
||||
{
|
||||
//Implementation Classes
|
||||
addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
|
||||
addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
|
||||
addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
|
||||
addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
|
||||
addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
|
||||
addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
|
||||
addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
|
||||
addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
|
||||
addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
|
||||
addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
|
||||
addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
|
||||
|
||||
//Abstract Classes
|
||||
addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
|
||||
|
||||
//Helper Classes
|
||||
addBiClassMapper("MAPS", "Maps", "2");
|
||||
|
||||
//Interfaces
|
||||
addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
|
||||
addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
|
||||
addBiClassMapper("SORTED_MAP", "SortedMap", "2");
|
||||
addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
|
||||
addBiClassMapper("MAP", "Map", "2");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadTestClasses()
|
||||
{
|
||||
//Implementation Classes
|
||||
addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
|
||||
addBiClassMapper("MAP_TESTS", "MapTests", "2");
|
||||
addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
|
||||
|
||||
//Abstract Classes
|
||||
addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
|
||||
|
||||
//Helper Classes
|
||||
addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
|
||||
addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
|
||||
addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
|
||||
addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
|
||||
addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
|
||||
addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
|
||||
}
|
||||
package speiger.src.builder.modules;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Set;
|
||||
import java.util.TreeSet;
|
||||
|
||||
import speiger.src.builder.ClassType;
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public class MapModule extends BaseModule
|
||||
{
|
||||
public static final BaseModule INSTANCE = new MapModule();
|
||||
|
||||
@Override
|
||||
public String getModuleName() { return "Map"; }
|
||||
@Override
|
||||
public boolean isBiModule() { return true; }
|
||||
@Override
|
||||
protected void loadVariables() {}
|
||||
@Override
|
||||
public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; }
|
||||
@Override
|
||||
public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); }
|
||||
|
||||
@Override
|
||||
public Set<String> getModuleKeys(ClassType keyType, ClassType valueType) {
|
||||
Set<String> sets = new TreeSet<>();
|
||||
sets.addAll(Arrays.asList("Wrappers", "Implementations"));
|
||||
sets.addAll(Arrays.asList("OrderedMap", "SortedMap"));
|
||||
sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap"));
|
||||
sets.addAll(Arrays.asList("HashMap", "LinkedHashMap"));
|
||||
sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap"));
|
||||
sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap"));
|
||||
sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap"));
|
||||
return sets;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadFlags()
|
||||
{
|
||||
if(isModuleEnabled()) addFlag("MAP_MODULE");
|
||||
if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE");
|
||||
boolean implementations = isModuleEnabled("Implementations");
|
||||
boolean hashMap = implementations && isModuleEnabled("HashMap");
|
||||
boolean customHashMap = implementations && isModuleEnabled("CustomHashMap");
|
||||
boolean enumMap = implementations && isModuleEnabled("EnumMap");
|
||||
|
||||
if(isModuleEnabled("OrderedMap")) {
|
||||
addFlag("ORDERED_MAP_FEATURE");
|
||||
if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE");
|
||||
if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE");
|
||||
if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE");
|
||||
if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE");
|
||||
}
|
||||
if(isModuleEnabled("SortedMap")) {
|
||||
addFlag("SORTED_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE");
|
||||
}
|
||||
if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE");
|
||||
if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE");
|
||||
if(hashMap) addFlag("MAP_FEATURE");
|
||||
if(customHashMap) addFlag("CUSTOM_MAP_FEATURE");
|
||||
if(enumMap) addFlag("ENUM_MAP_FEATURE");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadBlockades()
|
||||
{
|
||||
if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap");
|
||||
if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps");
|
||||
boolean implementations = !isModuleEnabled("Implementations");
|
||||
if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap");
|
||||
if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
|
||||
|
||||
boolean ordered = !isModuleEnabled("OrderedMap");
|
||||
if(ordered) addBlockedFiles("OrderedMap");
|
||||
boolean hashMap = implementations || !isModuleEnabled("HashMap");
|
||||
if(hashMap) addBlockedFiles("OpenHashMap");
|
||||
if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap");
|
||||
|
||||
boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap");
|
||||
if(customHashMap) addBlockedFiles("OpenCustomHashMap");
|
||||
if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap");
|
||||
|
||||
boolean enumMap = implementations || !isModuleEnabled("EnumMap");
|
||||
if(enumMap) addBlockedFiles("EnumMap");
|
||||
if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap");
|
||||
|
||||
if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap");
|
||||
|
||||
boolean sorted = !isModuleEnabled("SortedMap");
|
||||
if(sorted) addBlockedFiles("SortedMap", "NavigableMap");
|
||||
if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap");
|
||||
if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap");
|
||||
|
||||
if(keyType == ClassType.BOOLEAN)
|
||||
{
|
||||
//Main Classes
|
||||
addBlockedFiles("SortedMap", "NavigableMap", "RBTreeMap", "AVLTreeMap");
|
||||
addBlockedFiles("OrderedMap", "ArrayMap", "LinkedOpenHashMap", "LinkedOpenCustomHashMap");
|
||||
addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap");
|
||||
addBlockedFiles("Map", "Maps", "AbstractMap", "ImmutableOpenHashMap", "OpenHashMap", "OpenCustomHashMap");
|
||||
|
||||
//Test Classes
|
||||
addBlockedFiles("TestMap", "MapTests", "MapTestSuiteBuilder", "MapConstructorTests", "TestMapGenerator", "SimpleMapTestGenerator", "DerivedMapGenerators", "AbstractMapTester");
|
||||
addBlockedFiles("TestSortedMapGenerator", "OrderedMapTestSuiteBuilder", "NavigableMapTestSuiteBuilder", "SortedMapTestSuiteBuilder");
|
||||
addBlockedFiles("TestOrderedMapGenerator");
|
||||
addBlockedFilter(T -> T.endsWith("Tester") && (T.startsWith("Map") || T.startsWith("OrderedMap") || T.startsWith("SortedMap") || T.startsWith("NavigableMap")));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadRemappers()
|
||||
{
|
||||
//Main Classes
|
||||
addBiRequirement("Map");
|
||||
addBiRequirement("SortedMap");
|
||||
addBiRequirement("OrderedMap");
|
||||
addBiRequirement("NavigableMap");
|
||||
addBiRequirement("ConcurrentMap");
|
||||
addBiRequirement("AbstractMap");
|
||||
addEnumRequirement("EnumMap");
|
||||
addEnumRequirement("LinkedEnumMap");
|
||||
addBiRequirement("ConcurrentOpenHashMap");
|
||||
addBiRequirement("ImmutableOpenHashMap");
|
||||
addBiRequirement("OpenHashMap");
|
||||
addBiRequirement("LinkedOpenHashMap");
|
||||
addBiRequirement("OpenCustomHashMap");
|
||||
addBiRequirement("LinkedOpenCustomHashMap");
|
||||
addBiRequirement("ArrayMap");
|
||||
addBiRequirement("RBTreeMap");
|
||||
addBiRequirement("AVLTreeMap");
|
||||
addBiRequirement("Maps");
|
||||
|
||||
addRemapper("AbstractMap", "Abstract%sMap");
|
||||
addRemapper("EnumMap", "Enum2%sMap");
|
||||
addRemapper("LinkedEnumMap", "LinkedEnum2%sMap");
|
||||
addRemapper("ImmutableOpenHashMap", "Immutable%sOpenHashMap");
|
||||
|
||||
//Test Classes
|
||||
addBiRequirement("TestMapGenerator");
|
||||
addBiRequirement("TestSortedMapGenerator");
|
||||
addBiRequirement("TestOrderedMapGenerator");
|
||||
addBiRequirement("SimpleMapTestGenerator");
|
||||
addBiRequirement("DerivedMapGenerators");
|
||||
addBiRequirement("AbstractMapTester");
|
||||
addBiRequirement("MapTestSuiteBuilder");
|
||||
addBiRequirement("SortedMapTestSuiteBuilder");
|
||||
addBiRequirement("NavigableMapTestSuiteBuilder");
|
||||
addBiRequirement("OrderedMapTestSuiteBuilder");
|
||||
addBiRequirement("MapTests");
|
||||
addBiRequirement("MapConstructorTests");
|
||||
addBiRequirement("TestMap");
|
||||
addBiRequirement("MapAddToTester");
|
||||
addBiRequirement("MapSubFromTester");
|
||||
addBiRequirement("MapClearTester");
|
||||
addBiRequirement("MapComputeIfAbsentTester");
|
||||
addBiRequirement("MapComputeIfPresentTester");
|
||||
addBiRequirement("MapComputeTester");
|
||||
addBiRequirement("MapCopyTester");
|
||||
addBiRequirement("MapContainsTester");
|
||||
addBiRequirement("MapContainsKeyTester");
|
||||
addBiRequirement("MapContainsValueTester");
|
||||
addBiRequirement("MapCreatorTester");
|
||||
addBiRequirement("MapEntrySetTester");
|
||||
addBiRequirement("MapEqualsTester");
|
||||
addBiRequirement("MapForEachTester");
|
||||
addBiRequirement("MapGetOrDefaultTester");
|
||||
addBiRequirement("MapGetTester");
|
||||
addBiRequirement("MapHashCodeTester");
|
||||
addBiRequirement("MapIsEmptyTester");
|
||||
addBiRequirement("MapMergeTester");
|
||||
addBiRequirement("MapMergeBulkTester");
|
||||
addBiRequirement("MapPutAllArrayTester");
|
||||
addBiRequirement("MapPutAllTester");
|
||||
addBiRequirement("MapPutIfAbsentTester");
|
||||
addBiRequirement("MapPutTester");
|
||||
addBiRequirement("MapRemoveEntryTester");
|
||||
addBiRequirement("MapRemoveOrDefaultTester");
|
||||
addBiRequirement("MapRemoveTester");
|
||||
addBiRequirement("MapReplaceAllTester");
|
||||
addBiRequirement("MapReplaceEntryTester");
|
||||
addBiRequirement("MapReplaceTester");
|
||||
addBiRequirement("MapSizeTester");
|
||||
addBiRequirement("MapSupplyIfAbsentTester");
|
||||
addBiRequirement("MapToStringTester");
|
||||
addBiRequirement("NavigableMapNavigationTester");
|
||||
addBiRequirement("SortedMapNavigationTester");
|
||||
addBiRequirement("OrderedMapNavigationTester");
|
||||
addBiRequirement("OrderedMapMoveTester");
|
||||
addBiRequirement("MapConstructorTester");
|
||||
|
||||
addRemapper("TestMapGenerator", "Test%sMapGenerator");
|
||||
addRemapper("TestSortedMapGenerator", "Test%sSortedMapGenerator");
|
||||
addRemapper("TestOrderedMapGenerator", "Test%sOrderedMapGenerator");
|
||||
addRemapper("SimpleMapTestGenerator", "Simple%sMapTestGenerator");
|
||||
addRemapper("DerivedMapGenerators", "Derived%sMapGenerators");
|
||||
addRemapper("AbstractMapTester", "Abstract%sMapTester");
|
||||
addRemapper("TestMap", "Test%sMap");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadFunctions()
|
||||
{
|
||||
addFunctionValueMapper("BULK_MERGE", "mergeAll");
|
||||
addFunctionValueMappers("COMPUTE_IF_ABSENT", "compute%sIfAbsent");
|
||||
addFunctionValueMappers("COMPUTE_IF_PRESENT", "compute%sIfPresent");
|
||||
addFunctionValueMapper("COMPUTE", "compute");
|
||||
addFunctionMapper("DEQUEUE_LAST", "dequeueLast");
|
||||
addFunctionMapper("DEQUEUE", "dequeue");
|
||||
addSimpleMapper("ENTRY_SET", keyType.getFileType().toLowerCase()+"2"+valueType.getFileType()+"EntrySet");
|
||||
addFunctionMappers("FIRST_ENTRY_KEY", "first%sKey");
|
||||
addFunctionValueMappers("FIRST_ENTRY_VALUE", "first%sValue");
|
||||
if(keyType.isObject()) addFunctionValueMapper("GET_VALUE", valueType.isObject() ? "getObject" : "get");
|
||||
else addSimpleMapper("GET_VALUE", "get");
|
||||
addFunctionMappers("LAST_ENTRY_KEY", "last%sKey");
|
||||
addFunctionValueMappers("LAST_ENTRY_VALUE", "last%sValue");
|
||||
addFunctionValueMapper("MERGE", "merge");
|
||||
addFunctionMappers("POLL_FIRST_ENTRY_KEY", "pollFirst%sKey");
|
||||
addFunctionMappers("POLL_LAST_ENTRY_KEY", "pollLast%sKey");
|
||||
if(keyType.isObject()) addFunctionMapper("REMOVE_VALUE", "rem");
|
||||
else addSimpleMapper("REMOVE_VALUE", "remove");
|
||||
addFunctionMapper("REMOVE", "remove");
|
||||
addFunctionValueMappers("REPLACE_VALUES", valueType.isObject() ? "replaceObjects" : "replace%ss");
|
||||
addFunctionValueMappers("SUPPLY_IF_ABSENT", "supply%sIfAbsent");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadClasses()
|
||||
{
|
||||
//Implementation Classes
|
||||
addAbstractBiMapper("IMMUTABLE_HASH_MAP", "Immutable%sOpenHashMap", "2");
|
||||
addBiClassMapper("LINKED_CUSTOM_HASH_MAP", "LinkedOpenCustomHashMap", "2");
|
||||
addBiClassMapper("LINKED_HASH_MAP", "LinkedOpenHashMap", "2");
|
||||
addBiClassMapper("CUSTOM_HASH_MAP", "OpenCustomHashMap", "2");
|
||||
addBiClassMapper("CONCURRENT_HASH_MAP", "ConcurrentOpenHashMap", "2");
|
||||
addBiClassMapper("AVL_TREE_MAP", "AVLTreeMap", "2");
|
||||
addBiClassMapper("RB_TREE_MAP", "RBTreeMap", "2");
|
||||
addFunctionValueMappers("LINKED_ENUM_MAP", valueType.isObject() ? "LinkedEnum2ObjectMap" : "LinkedEnum2%sMap");
|
||||
addFunctionValueMappers("ENUM_MAP", valueType.isObject() ? "Enum2ObjectMap" : "Enum2%sMap");
|
||||
addBiClassMapper("HASH_MAP", "OpenHashMap", "2");
|
||||
addBiClassMapper("ARRAY_MAP", "ArrayMap", "2");
|
||||
|
||||
//Abstract Classes
|
||||
addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
|
||||
|
||||
//Helper Classes
|
||||
addBiClassMapper("MAPS", "Maps", "2");
|
||||
|
||||
//Interfaces
|
||||
addBiClassMapper("NAVIGABLE_MAP", "NavigableMap", "2");
|
||||
addBiClassMapper("ORDERED_MAP", "OrderedMap", "2");
|
||||
addBiClassMapper("SORTED_MAP", "SortedMap", "2");
|
||||
addBiClassMapper("CONCURRENT_MAP", "ConcurrentMap", "2");
|
||||
addBiClassMapper("MAP", "Map", "2");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void loadTestClasses()
|
||||
{
|
||||
//Implementation Classes
|
||||
addAbstractBiMapper("SIMPLE_TEST_MAP", "Test%sMap", "2");
|
||||
addBiClassMapper("MAP_TESTS", "MapTests", "2");
|
||||
addAbstractBiMapper("NAVIGABLE_MAP_TEST_BUILDER", "%sNavigableMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("SORTED_MAP_TEST_BUILDER", "%sSortedMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("ORDERED_MAP_TEST_BUILDER", "%sOrderedMapTestSuiteBuilder", "2");
|
||||
addAbstractBiMapper("MAP_TEST_BUILDER", "%sMapTestSuiteBuilder", "2");
|
||||
|
||||
//Abstract Classes
|
||||
addAbstractBiMapper("ABSTRACT_MAP_TESTER", "Abstract%sMapTester", "2");
|
||||
|
||||
//Helper Classes
|
||||
addAbstractBiMapper("MAP_CONSTRUCTOR_TESTS", "%sMapConstructorTests", "2");
|
||||
addAbstractBiMapper("SIMPLE_MAP_TEST_GENERATOR", "Simple%sMapTestGenerator", "2");
|
||||
addAbstractBiMapper("DERIVED_MAP_GENERATORS", "Derived%sMapGenerators", "2");
|
||||
addAbstractBiMapper("TEST_ORDERED_MAP_GENERATOR", "Test%sOrderedMapGenerator", "2");
|
||||
addAbstractBiMapper("TEST_SORTED_MAP_GENERATOR", "Test%sSortedMapGenerator", "2");
|
||||
addAbstractBiMapper("TEST_MAP_GENERATOR", "Test%sMapGenerator", "2");
|
||||
}
|
||||
}
|
||||
+265
-265
@@ -1,266 +1,266 @@
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Objects;
|
||||
import java.util.AbstractCollection;
|
||||
#if TYPE_OBJECT
|
||||
import java.util.function.Consumer;
|
||||
#endif
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
import speiger.src.collections.PACKAGE.utils.ITERATORS;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.ARRAYS;
|
||||
|
||||
/**
|
||||
* Abstract Type Specific Collection that reduces boxing/unboxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractCollection<CLASS_TYPE> implements COLLECTION KEY_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
public abstract ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean add(CLASS_TYPE e) { return COLLECTION.super.add(e); }
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();modified |= add(iter.NEXT()));
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean contains(Object e) { return COLLECTION.super.contains(e); }
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
|
||||
* @param e the element that should be searched for.
|
||||
* @return true if the value was found.
|
||||
*/
|
||||
@Override
|
||||
public boolean contains(KEY_TYPE e) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) { if(KEY_EQUALS(iter.NEXT(), e)) return true; }
|
||||
return false;
|
||||
}
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean addAll(Collection<? extends CLASS_TYPE> c)
|
||||
{
|
||||
return c instanceof COLLECTION ? addAll((COLLECTION KEY_GENERIC_TYPE)c) : super.addAll(c);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
|
||||
* @param c the collection that should be checked if it contains all elements.
|
||||
* @return true if all elements were found in the collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return true;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
if(!contains(iter.NEXT()))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsAll(Collection<?> c) {
|
||||
Objects.requireNonNull(c);
|
||||
return c instanceof COLLECTION ? containsAll((COLLECTION KEY_GENERIC_TYPE)c) : super.containsAll(c);
|
||||
}
|
||||
|
||||
/**
|
||||
* This implementation iterates over the elements of the collection and checks if they are stored in this collection
|
||||
* @param c the elements that should be checked for
|
||||
* @return true if any element is in this collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
@Primitive
|
||||
public boolean containsAny(Collection<?> c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
for(Object e : c)
|
||||
if(contains(e))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* This implementation iterates over the elements of the collection and checks if they are stored in this collection.
|
||||
* @param c the elements that should be checked for
|
||||
* @return true if any element is in this collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
if(contains(iter.NEXT()))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean remove(Object e) { return COLLECTION.super.remove(e); }
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
|
||||
* It stops after finding the first element
|
||||
* @param e the element that is searched for
|
||||
* @return true if the element was found and removed.
|
||||
*/
|
||||
@Override
|
||||
public boolean REMOVE_KEY(KEY_TYPE e) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(KEY_EQUALS(iter.NEXT(), e)) {
|
||||
iter.remove();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
|
||||
* @param c the elements that should be deleted
|
||||
* @return true if the collection was modified.
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(c.contains(iter.NEXT())) {
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
Objects.requireNonNull(r);
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE e = iter.NEXT();
|
||||
if(c.contains(e)) {
|
||||
r.accept(e);
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
|
||||
* @param c the elements that should be kept
|
||||
* @return true if the collection was modified.
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) {
|
||||
boolean modified = !isEmpty();
|
||||
clear();
|
||||
return modified;
|
||||
}
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(!c.contains(iter.NEXT())) {
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
|
||||
Objects.requireNonNull(c);
|
||||
Objects.requireNonNull(r);
|
||||
if(c.isEmpty()) {
|
||||
boolean modified = !isEmpty();
|
||||
forEach(r);
|
||||
clear();
|
||||
return modified;
|
||||
}
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE e = iter.NEXT();
|
||||
if(!c.contains(e)) {
|
||||
r.accept(e);
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific implementation of toArray that links to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
|
||||
* @return an array containing all of the elements in this collection
|
||||
*/
|
||||
@Override
|
||||
public KEY_TYPE[] TO_ARRAY() {
|
||||
if(isEmpty()) return ARRAYS.EMPTY_ARRAY;
|
||||
return TO_ARRAY(new KEY_TYPE[size()]);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
|
||||
* @param a array that the elements should be injected to. If null or to small a new array with the right size is created
|
||||
* @return an array containing all of the elements in this collection
|
||||
*/
|
||||
@Override
|
||||
public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
|
||||
if(a == null || a.length < size()) a = new KEY_TYPE[size()];
|
||||
ITERATORS.unwrap(a, iterator());
|
||||
if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
|
||||
return a;
|
||||
}
|
||||
#endif
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Objects;
|
||||
import java.util.AbstractCollection;
|
||||
#if TYPE_OBJECT
|
||||
import java.util.function.Consumer;
|
||||
#endif
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
import speiger.src.collections.PACKAGE.utils.ITERATORS;
|
||||
import speiger.src.collections.PACKAGE.utils.ARRAYS;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Abstract Type Specific Collection that reduces boxing/unboxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractCollection<CLASS_TYPE> implements COLLECTION KEY_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
public abstract ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean add(CLASS_TYPE e) { return COLLECTION.super.add(e); }
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public boolean addAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();modified |= add(iter.NEXT()));
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public COLLECTION KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean contains(Object e) { return COLLECTION.super.contains(e); }
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of contains. This implementation iterates over the elements and returns true if the value match.
|
||||
* @param e the element that should be searched for.
|
||||
* @return true if the value was found.
|
||||
*/
|
||||
@Override
|
||||
public boolean contains(KEY_TYPE e) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) { if(KEY_EQUALS(iter.NEXT(), e)) return true; }
|
||||
return false;
|
||||
}
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean addAll(Collection<? extends CLASS_TYPE> c)
|
||||
{
|
||||
return c instanceof COLLECTION ? addAll((COLLECTION KEY_GENERIC_TYPE)c) : super.addAll(c);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of containsAll. This implementation iterates over all elements and checks all elements are present in the other collection.
|
||||
* @param c the collection that should be checked if it contains all elements.
|
||||
* @return true if all elements were found in the collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return true;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
if(!contains(iter.NEXT()))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsAll(Collection<?> c) {
|
||||
Objects.requireNonNull(c);
|
||||
return c instanceof COLLECTION ? containsAll((COLLECTION KEY_GENERIC_TYPE)c) : super.containsAll(c);
|
||||
}
|
||||
|
||||
/**
|
||||
* This implementation iterates over the elements of the collection and checks if they are stored in this collection
|
||||
* @param c the elements that should be checked for
|
||||
* @return true if any element is in this collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
@Primitive
|
||||
public boolean containsAny(Collection<?> c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
for(Object e : c)
|
||||
if(contains(e))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* This implementation iterates over the elements of the collection and checks if they are stored in this collection.
|
||||
* @param c the elements that should be checked for
|
||||
* @return true if any element is in this collection
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
if(contains(iter.NEXT()))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public boolean remove(Object e) { return COLLECTION.super.remove(e); }
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of remove. This implementation iterates over the elements until it finds the element that is searched for or it runs out of elements.
|
||||
* It stops after finding the first element
|
||||
* @param e the element that is searched for
|
||||
* @return true if the element was found and removed.
|
||||
*/
|
||||
@Override
|
||||
public boolean REMOVE_KEY(KEY_TYPE e) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(KEY_EQUALS(iter.NEXT(), e)) {
|
||||
iter.remove();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific implementation of removeAll. This Implementation iterates over all elements and removes them as they were found in the other collection.
|
||||
* @param c the elements that should be deleted
|
||||
* @return true if the collection was modified.
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(c.contains(iter.NEXT())) {
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) return false;
|
||||
Objects.requireNonNull(r);
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE e = iter.NEXT();
|
||||
if(c.contains(e)) {
|
||||
r.accept(e);
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of retainAll. This Implementation iterates over all elements and removes them as they were not found in the other collection.
|
||||
* @param c the elements that should be kept
|
||||
* @return true if the collection was modified.
|
||||
* @throws java.lang.NullPointerException if the collection is null
|
||||
*/
|
||||
@Override
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
Objects.requireNonNull(c);
|
||||
if(c.isEmpty()) {
|
||||
boolean modified = !isEmpty();
|
||||
clear();
|
||||
return modified;
|
||||
}
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(!c.contains(iter.NEXT())) {
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r) {
|
||||
Objects.requireNonNull(c);
|
||||
Objects.requireNonNull(r);
|
||||
if(c.isEmpty()) {
|
||||
boolean modified = !isEmpty();
|
||||
forEach(r);
|
||||
clear();
|
||||
return modified;
|
||||
}
|
||||
boolean modified = false;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE e = iter.NEXT();
|
||||
if(!c.contains(e)) {
|
||||
r.accept(e);
|
||||
iter.remove();
|
||||
modified = true;
|
||||
}
|
||||
}
|
||||
return modified;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific implementation of toArray that links to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
|
||||
* @return an array containing all of the elements in this collection
|
||||
*/
|
||||
@Override
|
||||
public KEY_TYPE[] TO_ARRAY() {
|
||||
if(isEmpty()) return ARRAYS.EMPTY_ARRAY;
|
||||
return TO_ARRAY(new KEY_TYPE[size()]);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific implementation of toArray. This implementation iterates over all elements and unwraps them into primitive type.
|
||||
* @param a array that the elements should be injected to. If null or to small a new array with the right size is created
|
||||
* @return an array containing all of the elements in this collection
|
||||
*/
|
||||
@Override
|
||||
public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) {
|
||||
if(a == null || a.length < size()) a = new KEY_TYPE[size()];
|
||||
ITERATORS.unwrap(a, iterator());
|
||||
if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
|
||||
return a;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
+322
-321
@@ -1,322 +1,323 @@
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Collection;
|
||||
#if PRIMITIVES
|
||||
import java.util.Objects;
|
||||
import java.util.function.JAVA_PREDICATE;
|
||||
import java.util.function.Predicate;
|
||||
#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
|
||||
import java.util.stream.JAVA_STREAM;
|
||||
import java.util.stream.StreamSupport;
|
||||
#endif
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.IntFunction;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
#endif
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
|
||||
import speiger.src.collections.utils.ISizeProvider;
|
||||
import speiger.src.collections.utils.SanityChecks;
|
||||
|
||||
/**
|
||||
* A Type-Specific {@link Collection} that reduces (un)boxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE, ISizeProvider
|
||||
{
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific add function to reduce (un)boxing
|
||||
* @param o the element that should be added
|
||||
* @return true if the element was added to the collection
|
||||
*/
|
||||
public boolean add(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific addAll function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be added
|
||||
* @return true if elements were added into the collection
|
||||
*/
|
||||
public boolean addAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE... e) { return addAll(e, 0, e.length); }
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @param length how many elements of the array should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE[] e, int length) { return addAll(e, 0, length); }
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @param offset where to start within the array
|
||||
* @param length how many elements of the array should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE[] e, int offset, int length) {
|
||||
if(length <= 0) return false;
|
||||
SanityChecks.checkArrayCapacity(e.length, offset, length);
|
||||
boolean added = false;
|
||||
for(int i = 0;i<length;i++) {
|
||||
if(add(e[offset+i])) added = true;
|
||||
}
|
||||
return added;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific contains function to reduce (un)boxing
|
||||
* @param o the element that is checked for
|
||||
* @return true if the element is found in the collection
|
||||
*/
|
||||
public boolean contains(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific containsAll function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if all the element is found in the collection
|
||||
*/
|
||||
public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific containsAny function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if any element was found
|
||||
*/
|
||||
public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* Returns true if any element of the Collection is found in the provided collection.
|
||||
* A Small Optimization function to find out of any element is present when comparing collections and not all of them.
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if any element was found.
|
||||
*/
|
||||
@Primitive
|
||||
public boolean containsAny(Collection<?> c);
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific remove function that reduces (un)boxing.
|
||||
* @param o the element that should be removed
|
||||
* @return true if the element was removed
|
||||
* @see Collection#remove(Object)
|
||||
*/
|
||||
public boolean REMOVE_KEY(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific removeAll function that reduces (un)boxing.
|
||||
* @param c the collection of elements that should be removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#removeAll(Collection)
|
||||
*/
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific removeAll function that reduces (un)boxing.
|
||||
* It also notifies the remover of which exact element is going to be removed.
|
||||
* @param c the collection of elements that should be removed
|
||||
* @param r elements that got removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#removeAll(Collection)
|
||||
*/
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
|
||||
|
||||
/**
|
||||
* A Type-Specific retainAll function that reduces (un)boxing.
|
||||
* @param c the collection of elements that should be kept
|
||||
* @return true if any element was removed
|
||||
* @see Collection#retainAll(Collection)
|
||||
*/
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific retainAll function that reduces (un)boxing.
|
||||
* It also notifies the remover of which exact element is going to be removed.
|
||||
* @param c the collection of elements that should be kept
|
||||
* @param r elements that got removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#retainAll(Collection)
|
||||
*/
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to collect all elements
|
||||
* @param collection that the elements should be inserted to
|
||||
* @param <E> the collection type
|
||||
* @return the input with the desired elements
|
||||
*/
|
||||
default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
|
||||
collection.addAll(this);
|
||||
return collection;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Function that does a shallow clone of the Collection itself.
|
||||
* This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted.
|
||||
* It can be compared to Cloneable but with less exception risk
|
||||
* @return a Shallow Copy of the collection
|
||||
* @note Wrappers and view collections will not support this feature
|
||||
*/
|
||||
public COLLECTION KEY_GENERIC_TYPE copy();
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that simplifies the process of creating a new Array.
|
||||
* @param action the array creation function
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
return TO_ARRAY(action.apply(size()));
|
||||
}
|
||||
|
||||
#else
|
||||
/**
|
||||
* A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray()
|
||||
*/
|
||||
public KEY_TYPE[] TO_ARRAY();
|
||||
|
||||
/**
|
||||
* A Type-Specific toArray function that reduces (un)boxing.
|
||||
* @param a array that the elements should be injected to. If null or to small a new array with the right size is created
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a);
|
||||
|
||||
#if PRIMITIVES
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
|
||||
return remIf(v -> filter.test(KEY_TO_OBJ(SanityChecks.SANITY_CAST(v))));
|
||||
#else
|
||||
return remIf(v -> filter.test(KEY_TO_OBJ(v)));
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific removeIf function to reduce (un)boxing.
|
||||
* <p>Removes elements that were selected by the filter
|
||||
* @see Collection#removeIf(Predicate)
|
||||
* @param filter Filters the elements that should be removed
|
||||
* @return true if the collection was modified
|
||||
* @throws java.lang.NullPointerException if filter is null
|
||||
*/
|
||||
public default boolean remIf(JAVA_PREDICATE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
boolean removed = false;
|
||||
final ITERATOR each = iterator();
|
||||
while (each.hasNext()) {
|
||||
if (filter.test(each.NEXT())) {
|
||||
each.remove();
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
#endif
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean add(CLASS_TYPE o) { return add(OBJ_TO_KEY(o)); }
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean contains(Object o) { return o != null && contains(CLASS_TO_KEY(o)); }
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean remove(Object o) { return o != null && REMOVE_KEY(CLASS_TO_KEY(o)); }
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Returns a Type-Specific Iterator to reduce (un)boxing
|
||||
* @return a iterator of the collection
|
||||
* @see Collection#iterator()
|
||||
*/
|
||||
@Override
|
||||
public ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is Synchronized
|
||||
* @return a new Collection that is synchronized
|
||||
* @see COLLECTIONS#synchronize
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE synchronize() { return COLLECTIONS.synchronize(this); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is Synchronized
|
||||
* @param mutex is the controller of the synchronization block
|
||||
* @return a new Collection Wrapper that is synchronized
|
||||
* @see COLLECTIONS#synchronize
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE synchronize(Object mutex) { return COLLECTIONS.synchronize(this, mutex); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is unmodifiable
|
||||
* @return a new Collection Wrapper that is unmodifiable
|
||||
* @see COLLECTIONS#unmodifiable
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE unmodifiable() { return COLLECTIONS.unmodifiable(this); }
|
||||
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
#if PRIMITIVES
|
||||
/**
|
||||
* Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
|
||||
* @return a Stream of the closest java type
|
||||
*/
|
||||
default JAVA_STREAM primitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), false); }
|
||||
|
||||
/**
|
||||
* Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing.
|
||||
* @return a Stream of the closest java type
|
||||
*/
|
||||
default JAVA_STREAM parallelPrimitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), true); }
|
||||
|
||||
#endif
|
||||
#if STREAM_FEATURE
|
||||
/**
|
||||
* A Type Specific Type Splititerator to reduce boxing/unboxing
|
||||
* @return type specific splititerator
|
||||
*/
|
||||
@Override
|
||||
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
|
||||
#endif
|
||||
#endif
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Collection;
|
||||
#if PRIMITIVES
|
||||
import java.util.Objects;
|
||||
import java.util.function.JAVA_PREDICATE;
|
||||
import java.util.function.Predicate;
|
||||
#if SPLIT_ITERATOR_FEATURE && STREAM_FEATURE
|
||||
import java.util.stream.JAVA_STREAM;
|
||||
import java.util.stream.StreamSupport;
|
||||
#endif
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.IntFunction;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
#endif
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.COLLECTIONS;
|
||||
import speiger.src.collections.utils.ISizeProvider;
|
||||
import speiger.src.collections.utils.SanityChecks;
|
||||
|
||||
/**
|
||||
* A Type-Specific {@link Collection} that reduces (un)boxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface COLLECTION KEY_GENERIC_TYPE extends Collection<CLASS_TYPE>, ITERABLE KEY_GENERIC_TYPE, ISizeProvider
|
||||
{
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific add function to reduce (un)boxing
|
||||
* @param o the element that should be added
|
||||
* @return true if the element was added to the collection
|
||||
*/
|
||||
public boolean add(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific addAll function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be added
|
||||
* @return true if elements were added into the collection
|
||||
*/
|
||||
public boolean addAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE... e) { return addAll(e, 0, e.length); }
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @param length how many elements of the array should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE[] e, int length) { return addAll(e, 0, length); }
|
||||
|
||||
/**
|
||||
* A Type-Specific Array based addAll method to reduce the amount of Wrapping
|
||||
* @param e the elements that should be added
|
||||
* @param offset where to start within the array
|
||||
* @param length how many elements of the array should be added
|
||||
* @return if the collection was modified
|
||||
*/
|
||||
public default boolean addAll(KEY_TYPE[] e, int offset, int length) {
|
||||
if(length <= 0) return false;
|
||||
SanityChecks.checkArrayCapacity(e.length, offset, length);
|
||||
boolean added = false;
|
||||
for(int i = 0;i<length;i++) {
|
||||
if(add(e[offset+i])) added = true;
|
||||
}
|
||||
return added;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific contains function to reduce (un)boxing
|
||||
* @param o the element that is checked for
|
||||
* @return true if the element is found in the collection
|
||||
*/
|
||||
public boolean contains(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific containsAll function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if all the element is found in the collection
|
||||
*/
|
||||
public boolean containsAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific containsAny function to reduce (un)boxing
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if any element was found
|
||||
*/
|
||||
public boolean containsAny(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* Returns true if any element of the Collection is found in the provided collection.
|
||||
* A Small Optimization function to find out of any element is present when comparing collections and not all of them.
|
||||
* @param c the collection of elements that should be tested for
|
||||
* @return true if any element was found.
|
||||
*/
|
||||
@Primitive
|
||||
public boolean containsAny(Collection<?> c);
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type-Specific remove function that reduces (un)boxing.
|
||||
* @param o the element that should be removed
|
||||
* @return true if the element was removed
|
||||
* @see Collection#remove(Object)
|
||||
*/
|
||||
public boolean REMOVE_KEY(KEY_TYPE o);
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Type-Specific removeAll function that reduces (un)boxing.
|
||||
* @param c the collection of elements that should be removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#removeAll(Collection)
|
||||
*/
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific removeAll function that reduces (un)boxing.
|
||||
* It also notifies the remover of which exact element is going to be removed.
|
||||
* @param c the collection of elements that should be removed
|
||||
* @param r elements that got removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#removeAll(Collection)
|
||||
*/
|
||||
public boolean removeAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
|
||||
|
||||
/**
|
||||
* A Type-Specific retainAll function that reduces (un)boxing.
|
||||
* @param c the collection of elements that should be kept
|
||||
* @return true if any element was removed
|
||||
* @see Collection#retainAll(Collection)
|
||||
*/
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c);
|
||||
|
||||
/**
|
||||
* A Type-Specific retainAll function that reduces (un)boxing.
|
||||
* It also notifies the remover of which exact element is going to be removed.
|
||||
* @param c the collection of elements that should be kept
|
||||
* @param r elements that got removed
|
||||
* @return true if any element was removed
|
||||
* @see Collection#retainAll(Collection)
|
||||
*/
|
||||
public boolean retainAll(COLLECTION KEY_GENERIC_TYPE c, CONSUMER KEY_GENERIC_TYPE r);
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to collect all elements
|
||||
* @param collection that the elements should be inserted to
|
||||
* @param <E> the collection type
|
||||
* @return the input with the desired elements
|
||||
*/
|
||||
default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
|
||||
collection.addAll(this);
|
||||
return collection;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Function that does a shallow clone of the Collection itself.
|
||||
* This function is more optimized then a copy constructor since the Collection does not have to be unsorted/resorted.
|
||||
* It can be compared to Cloneable but with less exception risk
|
||||
* @return a Shallow Copy of the collection
|
||||
* @note Wrappers and view collections will not support this feature
|
||||
*/
|
||||
public COLLECTION KEY_GENERIC_TYPE copy();
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that simplifies the process of creating a new Array.
|
||||
* @param action the array creation function
|
||||
* @param <E> the returning arrayType
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
return TO_ARRAY(action.apply(size()));
|
||||
}
|
||||
|
||||
#else
|
||||
/**
|
||||
* A Type-Specific toArray function that delegates to {@link #TO_ARRAY(KEY_TYPE[])} with a newly created array.
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray()
|
||||
*/
|
||||
public KEY_TYPE[] TO_ARRAY();
|
||||
|
||||
/**
|
||||
* A Type-Specific toArray function that reduces (un)boxing.
|
||||
* @param a array that the elements should be injected to. If null or to small a new array with the right size is created
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a);
|
||||
|
||||
#if PRIMITIVES
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean removeIf(Predicate<? super CLASS_TYPE> filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
|
||||
return remIf(v -> filter.test(KEY_TO_OBJ(SanityChecks.SANITY_CAST(v))));
|
||||
#else
|
||||
return remIf(v -> filter.test(KEY_TO_OBJ(v)));
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type-Specific removeIf function to reduce (un)boxing.
|
||||
* <p>Removes elements that were selected by the filter
|
||||
* @see Collection#removeIf(Predicate)
|
||||
* @param filter Filters the elements that should be removed
|
||||
* @return true if the collection was modified
|
||||
* @throws java.lang.NullPointerException if filter is null
|
||||
*/
|
||||
public default boolean remIf(JAVA_PREDICATE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
boolean removed = false;
|
||||
final ITERATOR each = iterator();
|
||||
while (each.hasNext()) {
|
||||
if (filter.test(each.NEXT())) {
|
||||
each.remove();
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
#endif
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean add(CLASS_TYPE o) { return add(OBJ_TO_KEY(o)); }
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean contains(Object o) { return o != null && contains(CLASS_TO_KEY(o)); }
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean remove(Object o) { return o != null && REMOVE_KEY(CLASS_TO_KEY(o)); }
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Returns a Type-Specific Iterator to reduce (un)boxing
|
||||
* @return a iterator of the collection
|
||||
* @see Collection#iterator()
|
||||
*/
|
||||
@Override
|
||||
public ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is Synchronized
|
||||
* @return a new Collection that is synchronized
|
||||
* @see COLLECTIONS#synchronize
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE synchronize() { return COLLECTIONS.synchronize(this); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is Synchronized
|
||||
* @param mutex is the controller of the synchronization block
|
||||
* @return a new Collection Wrapper that is synchronized
|
||||
* @see COLLECTIONS#synchronize
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE synchronize(Object mutex) { return COLLECTIONS.synchronize(this, mutex); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped Collection that is unmodifiable
|
||||
* @return a new Collection Wrapper that is unmodifiable
|
||||
* @see COLLECTIONS#unmodifiable
|
||||
*/
|
||||
public default COLLECTION KEY_GENERIC_TYPE unmodifiable() { return COLLECTIONS.unmodifiable(this); }
|
||||
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
#if PRIMITIVES
|
||||
/**
|
||||
* Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
|
||||
* @return a Stream of the closest java type
|
||||
*/
|
||||
default JAVA_STREAM primitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), false); }
|
||||
|
||||
/**
|
||||
* Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing.
|
||||
* @return a Stream of the closest java type
|
||||
*/
|
||||
default JAVA_STREAM parallelPrimitiveStream() { return StreamSupport.NEW_STREAM(SPLIT_ITERATORS.createJavaSplititerator(this, 0), true); }
|
||||
|
||||
#endif
|
||||
#if STREAM_FEATURE
|
||||
/**
|
||||
* A Type Specific Type Splititerator to reduce boxing/unboxing
|
||||
* @return type specific splititerator
|
||||
*/
|
||||
@Override
|
||||
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
+457
-456
@@ -1,457 +1,458 @@
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.function.Consumer;
|
||||
#if JDK_FUNCTION
|
||||
import java.util.function.PREDICATE;
|
||||
#endif
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
import speiger.src.collections.objects.collections.ObjectIterable;
|
||||
#else
|
||||
import java.util.function.BiFunction;
|
||||
import java.util.function.IntFunction;
|
||||
import java.util.Comparator;
|
||||
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
|
||||
import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
|
||||
import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
|
||||
#if !JDK_FUNCTION
|
||||
import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
|
||||
#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
#if ARRAY_LIST_FEATURE
|
||||
import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
|
||||
#endif
|
||||
#endif
|
||||
#if SET_MODULE && !TYPE_BOOLEAN
|
||||
#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.SET;
|
||||
#if LINKED_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
|
||||
#else if LINKED_CUSTOM_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
|
||||
#else if SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.HASH_SET;
|
||||
#else if CUSTOM_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
|
||||
#else if RB_TREE_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
|
||||
#else if AVL_TREE_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
|
||||
#else if ARRAY_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.ARRAYS;
|
||||
#if ASYNC_MODULE
|
||||
import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
|
||||
#endif
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.ITERABLES;
|
||||
import speiger.src.collections.PACKAGE.utils.ITERATORS;
|
||||
#if !LINKED_HASH_SET_FEATURE && LINKED_CUSTOM_HASH_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.STRATEGY;
|
||||
#endif
|
||||
import speiger.src.collections.utils.ISizeProvider;
|
||||
|
||||
/**
|
||||
* A Type-Specific {@link Iterable} that reduces (un)boxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
|
||||
{
|
||||
/**
|
||||
* Returns an iterator over elements of type {@code T}.
|
||||
*
|
||||
* @return an Iterator.
|
||||
*/
|
||||
@Override
|
||||
ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type Specific foreach function that reduces (un)boxing
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
* <pre>{@code
|
||||
* iterator().forEachRemaining(action);
|
||||
* }</pre>
|
||||
*
|
||||
* @param action The action to be performed for each element
|
||||
* @throws NullPointerException if the specified action is null
|
||||
* @see Iterable#forEach(Consumer)
|
||||
*/
|
||||
default void forEach(CONSUMER action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(action);
|
||||
}
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Deprecated
|
||||
@Override
|
||||
default void forEach(Consumer<? super CLASS_TYPE> action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(action);
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
|
||||
* @param action The action to be performed for each element
|
||||
* @throws java.lang.NullPointerException if the specified action is null
|
||||
*/
|
||||
public default void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
|
||||
Objects.requireNonNull(action);
|
||||
int index = 0;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();action.accept(index++, iter.NEXT()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
|
||||
* @param input the object that should be included
|
||||
* @param action The action to be performed for each element
|
||||
* @param <E> the generic type of the Object
|
||||
* @throws java.lang.NullPointerException if the specified action is null
|
||||
*/
|
||||
default <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(input, action);
|
||||
}
|
||||
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
/**
|
||||
* A Type Specific Type Splititerator to reduce boxing/unboxing
|
||||
* @return type specific splititerator
|
||||
*/
|
||||
@Override
|
||||
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createUnknownSplititerator(iterator(), 0); }
|
||||
|
||||
#endif
|
||||
#if ASYNC_MODULE
|
||||
/**
|
||||
* Creates a Async Builder for moving work of the thread.
|
||||
* It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
|
||||
* @see ASYNC_BUILDER
|
||||
* @return a AsyncBuilder
|
||||
*/
|
||||
default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
|
||||
return new ASYNC_BUILDERBRACES(this);
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the mapping function
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
*/
|
||||
default <E> ObjectIterable<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
|
||||
return ITERABLES.map(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the flatMapping function
|
||||
* @param <V> The return type supplier.
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
|
||||
return ITERABLES.flatMap(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the flatMapping function
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default <E> ObjectIterable<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
|
||||
return ITERABLES.arrayFlatMap(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
|
||||
* @param filter the elements that should be kept.
|
||||
* @return a Iterable that filtered out all unwanted elements
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
return ITERABLES.filter(this, filter);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
|
||||
* @return a Iterable that filtered out all duplicated elements
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE distinct() {
|
||||
return ITERABLES.distinct(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
|
||||
* @param repeats how many times the elements should be repeated
|
||||
* @return a Iterable that is repeating multiple times
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE repeat(int repeats) {
|
||||
return ITERABLES.repeat(this, repeats);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to limit the amount of elements
|
||||
* @param limit the amount of elements it should be limited to
|
||||
* @return a Iterable that is limited in length
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE limit(long limit) {
|
||||
return ITERABLES.limit(this, limit);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to sort the elements
|
||||
* @param sorter that sorts the elements.
|
||||
* @return a Iterable that is sorted
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
|
||||
return ITERABLES.sorted(this, sorter);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
|
||||
* @param action the action that should be applied
|
||||
* @return a Peeked Iterable
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
|
||||
return ITERABLES.peek(this, action);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to collect all elements
|
||||
* @param collection that the elements should be inserted to
|
||||
* @param <E> the collection type
|
||||
* @return the input with the desired elements
|
||||
*/
|
||||
default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
|
||||
ITERATORS.pour(iterator(), collection);
|
||||
return collection;
|
||||
}
|
||||
|
||||
#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
|
||||
* @return a new ArrayList of all elements
|
||||
*/
|
||||
default LIST KEY_GENERIC_TYPE pourAsList() {
|
||||
#if ARRAY_LIST_FEATURE
|
||||
return pour(new ARRAY_LISTBRACES());
|
||||
#else
|
||||
return pour(new LINKED_LISTBRACES());
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
#if !TYPE_BOOLEAN && SET_MODULE
|
||||
#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a LinkedHashSet
|
||||
* @return a new LinkedHashSet of all elements
|
||||
*/
|
||||
default SET KEY_GENERIC_TYPE pourAsSet() {
|
||||
#if LINKED_SET_FEATURE
|
||||
return pour(new LINKED_HASH_SETBRACES());
|
||||
#else if LINKED_CUSTOM_SET_FEATURE
|
||||
return pour(new LINKED_CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
|
||||
#else if SET_FEATURE
|
||||
return pour(new HASH_SETBRACES());
|
||||
#else if CUSTOM_SET_FEATURE
|
||||
return pour(new CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
|
||||
#else if RB_TREE_SET_FEATURE
|
||||
return pour(new RB_Tree_SETBRACES());
|
||||
#else if AVL_TREE_SET_FEATURE
|
||||
return pour(new AVL_Tree_SETBRACES());
|
||||
#else if ARRAY_SET_FEATURE
|
||||
return pour(new ARRAY_SETBRACES());
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a Array
|
||||
* @param action is the creator function of said Array to ensure type is kept.
|
||||
* @return a new Array of all elements
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
ISizeProvider prov = ISizeProvider.of(this);
|
||||
if(prov != null) {
|
||||
int size = prov.size();
|
||||
if(size >= 0) {
|
||||
E[] array = action.apply(size);
|
||||
ITERATORS.unwrap(array, iterator());
|
||||
return array;
|
||||
}
|
||||
}
|
||||
return ARRAYS.pour(iterator(), action);
|
||||
}
|
||||
#else
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a Array
|
||||
* @return a new Array of all elements
|
||||
*/
|
||||
default KEY_TYPE[] TO_ARRAY() {
|
||||
ISizeProvider prov = ISizeProvider.of(this);
|
||||
if(prov != null) {
|
||||
int size = prov.size();
|
||||
if(size >= 0) {
|
||||
KEY_TYPE[] array = NEW_KEY_ARRAY(size);
|
||||
ITERATORS.unwrap(array, iterator());
|
||||
return array;
|
||||
}
|
||||
}
|
||||
return ARRAYS.pour(iterator());
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for any matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if any matches were found
|
||||
*/
|
||||
default boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for no matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if no matches were found
|
||||
*/
|
||||
default boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for all matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if all matches.
|
||||
*/
|
||||
default boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(!filter.test(iter.NEXT())) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for the first match.
|
||||
* @param filter that should be applied
|
||||
* @return the found value or the null equivalent variant.
|
||||
*/
|
||||
default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE entry = iter.NEXT();
|
||||
if(filter.test(entry)) return entry;
|
||||
}
|
||||
return EMPTY_VALUE;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @param identity the start value
|
||||
* @return the reduction result, returns identity if nothing was found
|
||||
*/
|
||||
default KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_TYPE state = identity;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
#else
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @param identity the start value
|
||||
* @Type(E)
|
||||
* @return the reduction result, returns identity if nothing was found
|
||||
*/
|
||||
default <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_SPECIAL_TYPE state = identity;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @return the reduction result, returns null value if nothing was found
|
||||
*/
|
||||
default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_TYPE state = EMPTY_VALUE;
|
||||
boolean empty = true;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(empty) {
|
||||
empty = false;
|
||||
state = iter.NEXT();
|
||||
continue;
|
||||
}
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to count the valid elements.
|
||||
* @param filter that should be applied
|
||||
* @return the amount of Valid Elements
|
||||
*/
|
||||
default int count(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
int result = 0;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) result++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
package speiger.src.collections.PACKAGE.collections;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.function.Consumer;
|
||||
#if JDK_FUNCTION
|
||||
import java.util.function.PREDICATE;
|
||||
#endif
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
|
||||
import speiger.src.collections.PACKAGE.functions.CONSUMER;
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
import speiger.src.collections.objects.collections.ObjectIterable;
|
||||
#else
|
||||
import java.util.function.BiFunction;
|
||||
import java.util.function.IntFunction;
|
||||
import java.util.Comparator;
|
||||
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.functions.function.TO_OBJECT_FUNCTION;
|
||||
import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
|
||||
import speiger.src.collections.objects.functions.consumer.BI_FROM_OBJECT_CONSUMER;
|
||||
#if !JDK_FUNCTION
|
||||
import speiger.src.collections.PACKAGE.functions.function.PREDICATE;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
|
||||
#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
|
||||
import speiger.src.collections.PACKAGE.lists.LIST;
|
||||
#if ARRAY_LIST_FEATURE
|
||||
import speiger.src.collections.PACKAGE.lists.ARRAY_LIST;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.lists.LINKED_LIST;
|
||||
#endif
|
||||
#endif
|
||||
#if SET_MODULE && !TYPE_BOOLEAN
|
||||
#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.SET;
|
||||
#if LINKED_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_HASH_SET;
|
||||
#else if LINKED_CUSTOM_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.LINKED_CUSTOM_HASH_SET;
|
||||
#else if SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.HASH_SET;
|
||||
#else if CUSTOM_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.CUSTOM_HASH_SET;
|
||||
#else if RB_TREE_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.RB_TREE_SET;
|
||||
#else if AVL_TREE_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.AVL_TREE_SET;
|
||||
#else if ARRAY_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.sets.ARRAY_SET;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.ARRAYS;
|
||||
#if ASYNC_MODULE
|
||||
import speiger.src.collections.PACKAGE.utils.ASYNC_BUILDER;
|
||||
#endif
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.utils.ITERABLES;
|
||||
import speiger.src.collections.PACKAGE.utils.ITERATORS;
|
||||
#if !LINKED_HASH_SET_FEATURE && LINKED_CUSTOM_HASH_SET_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.STRATEGY;
|
||||
#endif
|
||||
import speiger.src.collections.utils.ISizeProvider;
|
||||
|
||||
/**
|
||||
* A Type-Specific {@link Iterable} that reduces (un)boxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface ITERABLE KEY_GENERIC_TYPE extends Iterable<CLASS_TYPE>
|
||||
{
|
||||
/**
|
||||
* Returns an iterator over elements of type {@code T}.
|
||||
*
|
||||
* @return an Iterator.
|
||||
*/
|
||||
@Override
|
||||
ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type Specific foreach function that reduces (un)boxing
|
||||
*
|
||||
* @implSpec
|
||||
* <p>The default implementation behaves as if:
|
||||
* <pre>{@code
|
||||
* iterator().forEachRemaining(action);
|
||||
* }</pre>
|
||||
*
|
||||
* @param action The action to be performed for each element
|
||||
* @throws NullPointerException if the specified action is null
|
||||
* @see Iterable#forEach(Consumer)
|
||||
*/
|
||||
default void forEach(CONSUMER action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(action);
|
||||
}
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Deprecated
|
||||
@Override
|
||||
default void forEach(Consumer<? super CLASS_TYPE> action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(action);
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Indexed forEach implementation that allows you to keep track of how many elements were already iterated over.
|
||||
* @param action The action to be performed for each element
|
||||
* @throws java.lang.NullPointerException if the specified action is null
|
||||
*/
|
||||
public default void forEachIndexed(BI_FROM_INT_CONSUMER KEY_GENERIC_TYPE action) {
|
||||
Objects.requireNonNull(action);
|
||||
int index = 0;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();action.accept(index++, iter.NEXT()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce Lambda usage and allow for more method references, since these are faster/cleaner.
|
||||
* @param input the object that should be included
|
||||
* @param action The action to be performed for each element
|
||||
* @param <E> the generic type of the Object
|
||||
* @throws java.lang.NullPointerException if the specified action is null
|
||||
*/
|
||||
default <E> void forEach(E input, BI_FROM_OBJECT_CONSUMER KSK_GENERIC_TYPE<E> action) {
|
||||
Objects.requireNonNull(action);
|
||||
iterator().forEachRemaining(input, action);
|
||||
}
|
||||
|
||||
#if SPLIT_ITERATOR_FEATURE
|
||||
/**
|
||||
* A Type Specific Type Splititerator to reduce boxing/unboxing
|
||||
* @return type specific splititerator
|
||||
*/
|
||||
@Override
|
||||
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createUnknownSplititerator(iterator(), 0); }
|
||||
|
||||
#endif
|
||||
#if ASYNC_MODULE
|
||||
/**
|
||||
* Creates a Async Builder for moving work of the thread.
|
||||
* It is not designed to split the work to multithreaded work, so using this keep it singlethreaded, but it allows to be moved to another thread.
|
||||
* @see ASYNC_BUILDER
|
||||
* @return a AsyncBuilder
|
||||
*/
|
||||
default ASYNC_BUILDER KEY_GENERIC_TYPE asAsync() {
|
||||
return new ASYNC_BUILDERBRACES(this);
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the mapping function
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
*/
|
||||
default <E> ObjectIterable<E> map(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E> mapper) {
|
||||
return ITERABLES.map(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the flatMapping function
|
||||
* @param <V> The return type supplier.
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default <E, V extends Iterable<E>> ObjectIterable<E> flatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<V> mapper) {
|
||||
return ITERABLES.flatMap(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to convert a Iterable to something else.
|
||||
* @param mapper the flatMapping function
|
||||
* @param <E> The return type.
|
||||
* @return a new Iterable that returns the desired result
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default <E> ObjectIterable<E> arrayflatMap(TO_OBJECT_FUNCTION KKS_GENERIC_TYPE<E[]> mapper) {
|
||||
return ITERABLES.arrayFlatMap(this, mapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to filter out unwanted elements
|
||||
* @param filter the elements that should be kept.
|
||||
* @return a Iterable that filtered out all unwanted elements
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE filter(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
return ITERABLES.filter(this, filter);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to filter out duplicated elements
|
||||
* @return a Iterable that filtered out all duplicated elements
|
||||
* @note does not support TO_ARRAY optimizations.
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE distinct() {
|
||||
return ITERABLES.distinct(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to repeat elements a desired amount of times
|
||||
* @param repeats how many times the elements should be repeated
|
||||
* @return a Iterable that is repeating multiple times
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE repeat(int repeats) {
|
||||
return ITERABLES.repeat(this, repeats);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to limit the amount of elements
|
||||
* @param limit the amount of elements it should be limited to
|
||||
* @return a Iterable that is limited in length
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE limit(long limit) {
|
||||
return ITERABLES.limit(this, limit);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to sort the elements
|
||||
* @param sorter that sorts the elements.
|
||||
* @return a Iterable that is sorted
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE sorted(COMPARATOR KEY_GENERIC_TYPE sorter) {
|
||||
return ITERABLES.sorted(this, sorter);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to preview elements before they are iterated through
|
||||
* @param action the action that should be applied
|
||||
* @return a Peeked Iterable
|
||||
*/
|
||||
default ITERABLE KEY_GENERIC_TYPE peek(CONSUMER KEY_GENERIC_TYPE action) {
|
||||
return ITERABLES.peek(this, action);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Helper function to reduce the usage of Streams and allows to collect all elements
|
||||
* @param collection that the elements should be inserted to
|
||||
* @param <E> the collection type
|
||||
* @return the input with the desired elements
|
||||
*/
|
||||
default <E extends COLLECTION KEY_GENERIC_TYPE> E pour(E collection) {
|
||||
ITERATORS.pour(iterator(), collection);
|
||||
return collection;
|
||||
}
|
||||
|
||||
#if ARRAY_LIST_FEATURE || LINKED_LIST_FEATURE
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a ArrayList
|
||||
* @return a new ArrayList of all elements
|
||||
*/
|
||||
default LIST KEY_GENERIC_TYPE pourAsList() {
|
||||
#if ARRAY_LIST_FEATURE
|
||||
return pour(new ARRAY_LISTBRACES());
|
||||
#else
|
||||
return pour(new LINKED_LISTBRACES());
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
#if !TYPE_BOOLEAN && SET_MODULE
|
||||
#if LINKED_SET_FEATURE || LINKED_CUSTOM_SET_FEATURE || SET_FEATURE || CUSTOM_SET_FEATURE || RB_TREE_SET_FEATURE || AVL_TREE_SET_FEATURE || ARRAY_SET_FEATURE
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a LinkedHashSet
|
||||
* @return a new LinkedHashSet of all elements
|
||||
*/
|
||||
default SET KEY_GENERIC_TYPE pourAsSet() {
|
||||
#if LINKED_SET_FEATURE
|
||||
return pour(new LINKED_HASH_SETBRACES());
|
||||
#else if LINKED_CUSTOM_SET_FEATURE
|
||||
return pour(new LINKED_CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
|
||||
#else if SET_FEATURE
|
||||
return pour(new HASH_SETBRACES());
|
||||
#else if CUSTOM_SET_FEATURE
|
||||
return pour(new CUSTOM_HASH_SETBRACES(STRATEGY.normalStrategy()));
|
||||
#else if RB_TREE_SET_FEATURE
|
||||
return pour(new RB_Tree_SETBRACES());
|
||||
#else if AVL_TREE_SET_FEATURE
|
||||
return pour(new AVL_Tree_SETBRACES());
|
||||
#else if ARRAY_SET_FEATURE
|
||||
return pour(new ARRAY_SETBRACES());
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a Array
|
||||
* @param action is the creator function of said Array to ensure type is kept.
|
||||
* @param <E> the returning arrayType
|
||||
* @return a new Array of all elements
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
ISizeProvider prov = ISizeProvider.of(this);
|
||||
if(prov != null) {
|
||||
int size = prov.size();
|
||||
if(size >= 0) {
|
||||
E[] array = action.apply(size);
|
||||
ITERATORS.unwrap(array, iterator());
|
||||
return array;
|
||||
}
|
||||
}
|
||||
return ARRAYS.pour(iterator(), action);
|
||||
}
|
||||
#else
|
||||
/**
|
||||
* A Helper function that reduces the usage of streams and allows to collect all elements as a Array
|
||||
* @return a new Array of all elements
|
||||
*/
|
||||
default KEY_TYPE[] TO_ARRAY() {
|
||||
ISizeProvider prov = ISizeProvider.of(this);
|
||||
if(prov != null) {
|
||||
int size = prov.size();
|
||||
if(size >= 0) {
|
||||
KEY_TYPE[] array = NEW_KEY_ARRAY(size);
|
||||
ITERATORS.unwrap(array, iterator());
|
||||
return array;
|
||||
}
|
||||
}
|
||||
return ARRAYS.pour(iterator());
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for any matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if any matches were found
|
||||
*/
|
||||
default boolean matchesAny(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for no matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if no matches were found
|
||||
*/
|
||||
default boolean matchesNone(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for all matches.
|
||||
* @param filter that should be applied
|
||||
* @return true if all matches.
|
||||
*/
|
||||
default boolean matchesAll(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(!filter.test(iter.NEXT())) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to filter for the first match.
|
||||
* @param filter that should be applied
|
||||
* @return the found value or the null equivalent variant.
|
||||
*/
|
||||
default KEY_TYPE findFirst(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
KEY_TYPE entry = iter.NEXT();
|
||||
if(filter.test(entry)) return entry;
|
||||
}
|
||||
return EMPTY_VALUE;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @param identity the start value
|
||||
* @return the reduction result, returns identity if nothing was found
|
||||
*/
|
||||
default KEY_TYPE reduce(KEY_TYPE identity, UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_TYPE state = identity;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
#else
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @param identity the start value
|
||||
* @Type(E)
|
||||
* @return the reduction result, returns identity if nothing was found
|
||||
*/
|
||||
default <KEY_SPECIAL_TYPE> KEY_SPECIAL_TYPE reduce(KEY_SPECIAL_TYPE identity, BiFunction<KEY_SPECIAL_TYPE, KEY_TYPE, KEY_SPECIAL_TYPE> operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_SPECIAL_TYPE state = identity;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
#endif
|
||||
/**
|
||||
* Performs a <a href="package-summary.html#Reduction">reduction</a> on the
|
||||
* elements of this Iterable
|
||||
* @param operator the operation that should be applied
|
||||
* @return the reduction result, returns null value if nothing was found
|
||||
*/
|
||||
default KEY_TYPE reduce(UNARY_OPERATOR KEY_KEY_GENERIC_TYPE operator) {
|
||||
Objects.requireNonNull(operator);
|
||||
KEY_TYPE state = EMPTY_VALUE;
|
||||
boolean empty = true;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(empty) {
|
||||
empty = false;
|
||||
state = iter.NEXT();
|
||||
continue;
|
||||
}
|
||||
state = operator.APPLY_VALUE(state, iter.NEXT());
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to reduce stream usage that allows to count the valid elements.
|
||||
* @param filter that should be applied
|
||||
* @return the amount of Valid Elements
|
||||
*/
|
||||
default int count(PREDICATE KEY_GENERIC_TYPE filter) {
|
||||
Objects.requireNonNull(filter);
|
||||
int result = 0;
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = iterator();iter.hasNext();) {
|
||||
if(filter.test(iter.NEXT())) result++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
+69
-69
@@ -1,70 +1,70 @@
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Type-Specific Class for Comparator to reduce (un)boxing
|
||||
*/
|
||||
public interface COMPARATOR extends Comparator<CLASS_TYPE>
|
||||
{
|
||||
/**
|
||||
* Type-Specific compare function to reduce (un)boxing
|
||||
* @param o1 the first object to be compared.
|
||||
* @param o2 the second object to be compared.
|
||||
* @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
|
||||
* @see Comparator#compare(Object, Object)
|
||||
*/
|
||||
int compare(KEY_TYPE o1, KEY_TYPE o2);
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
default int compare(CLASS_TYPE o1, CLASS_TYPE o2) {
|
||||
return compare(OBJ_TO_KEY(o1), OBJ_TO_KEY(o2));
|
||||
}
|
||||
|
||||
/**
|
||||
* A Wrapper function to convert a Non-Type-Specific Comparator to a Type-Specific-Comparator
|
||||
* @param c comparator to convert
|
||||
* @return the wrapper of the comparator
|
||||
* @throws NullPointerException if the comparator is null
|
||||
*/
|
||||
public static COMPARATOR of(Comparator<CLASS_TYPE> c) {
|
||||
Objects.requireNonNull(c);
|
||||
return (K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V));
|
||||
}
|
||||
|
||||
@Override
|
||||
public default COMPARATOR reversed() {
|
||||
return new Reversed(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type Specific Reversed Comparator to reduce boxing/unboxing
|
||||
*/
|
||||
static class Reversed implements COMPARATOR
|
||||
{
|
||||
COMPARATOR original;
|
||||
|
||||
/**
|
||||
* default constructor
|
||||
* @param original that is going to be reversed
|
||||
*/
|
||||
public Reversed(COMPARATOR original) {
|
||||
this.original = original;
|
||||
}
|
||||
|
||||
public int compare(KEY_TYPE o1, KEY_TYPE o2) {
|
||||
return original.compare(o2, o1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public COMPARATOR reversed() {
|
||||
return original;
|
||||
}
|
||||
}
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Type-Specific Class for Comparator to reduce (un)boxing
|
||||
*/
|
||||
public interface COMPARATOR extends Comparator<CLASS_TYPE>
|
||||
{
|
||||
/**
|
||||
* Type-Specific compare function to reduce (un)boxing
|
||||
* @param o1 the first object to be compared.
|
||||
* @param o2 the second object to be compared.
|
||||
* @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
|
||||
* @see Comparator#compare(Object, Object)
|
||||
*/
|
||||
int compare(KEY_TYPE o1, KEY_TYPE o2);
|
||||
|
||||
/** {@inheritDoc}
|
||||
* <p>This default implementation delegates to the corresponding type-specific function.
|
||||
* @deprecated Please use the corresponding type-specific function instead.
|
||||
*/
|
||||
@Override
|
||||
@Deprecated
|
||||
default int compare(CLASS_TYPE o1, CLASS_TYPE o2) {
|
||||
return compare(OBJ_TO_KEY(o1), OBJ_TO_KEY(o2));
|
||||
}
|
||||
|
||||
/**
|
||||
* A Wrapper function to convert a Non-Type-Specific Comparator to a Type-Specific-Comparator
|
||||
* @param c comparator to convert
|
||||
* @return the wrapper of the comparator
|
||||
* @throws NullPointerException if the comparator is null
|
||||
*/
|
||||
public static COMPARATOR of(Comparator<CLASS_TYPE> c) {
|
||||
Objects.requireNonNull(c);
|
||||
return (K, V) -> c.compare(KEY_TO_OBJ(K), KEY_TO_OBJ(V));
|
||||
}
|
||||
|
||||
@Override
|
||||
public default COMPARATOR reversed() {
|
||||
return new Reversed(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type Specific Reversed Comparator to reduce boxing/unboxing
|
||||
*/
|
||||
static class Reversed implements COMPARATOR
|
||||
{
|
||||
COMPARATOR original;
|
||||
|
||||
/**
|
||||
* default constructor
|
||||
* @param original that is going to be reversed
|
||||
*/
|
||||
public Reversed(COMPARATOR original) {
|
||||
this.original = original;
|
||||
}
|
||||
|
||||
public int compare(KEY_TYPE o1, KEY_TYPE o2) {
|
||||
return original.compare(o2, o1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public COMPARATOR reversed() {
|
||||
return original;
|
||||
}
|
||||
}
|
||||
}
|
||||
+18
-18
@@ -1,19 +1,19 @@
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
/**
|
||||
* Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
|
||||
* @Type(T)
|
||||
*/
|
||||
#if TYPE_OBJECT
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE extends java.util.function.Supplier<KEY_TYPE>
|
||||
#else if JDK_TYPE && !TYPE_BOOLEAN
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE extends JAVA_SUPPLIER
|
||||
#else
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE
|
||||
#endif
|
||||
{
|
||||
/**
|
||||
* @return the supplied value
|
||||
*/
|
||||
public KEY_TYPE SUPPLY_GET();
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
/**
|
||||
* Type-Specific Supplier interface that reduces (un)boxing and allows to merge other consumer types into this interface
|
||||
* @Type(T)
|
||||
*/
|
||||
#if TYPE_OBJECT
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE extends java.util.function.Supplier<KEY_TYPE>
|
||||
#else if JDK_TYPE && !TYPE_BOOLEAN
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE extends JAVA_SUPPLIER
|
||||
#else
|
||||
public interface SUPPLIER KEY_GENERIC_TYPE
|
||||
#endif
|
||||
{
|
||||
/**
|
||||
* @return the supplied value
|
||||
*/
|
||||
public KEY_TYPE SUPPLY_GET();
|
||||
}
|
||||
+91
-91
@@ -1,92 +1,92 @@
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
import java.util.concurrent.RunnableFuture;
|
||||
#if !TYPE_OBJECT
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.TimeoutException;
|
||||
#endif
|
||||
|
||||
/**
|
||||
*
|
||||
* A Type Specific Task interface that allows you to keep track of the task that is currently running.<br>
|
||||
* It extends Runnable future and supports said functions but also provides quality of life functions like:<br>
|
||||
*
|
||||
* - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed.
|
||||
* - pause/resume: which allows to pause/resume the task at any moment, making it easier to create thread-safe actions.
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface TASK KEY_GENERIC_TYPE extends RunnableFuture<CLASS_TYPE> {
|
||||
/**
|
||||
* Helper function to detect if the task is currently paused.
|
||||
* @return true if paused
|
||||
*/
|
||||
public boolean isPaused();
|
||||
|
||||
/**
|
||||
* Pauses the task, which lets the thread finish without completing the task.
|
||||
* Tasks are written in the way where they can pause without any issues.
|
||||
* This won't be instant, as this function is applied asynchronous and doesn't check if the thread paused.
|
||||
* So make sure it had the time to pause.
|
||||
*/
|
||||
public void pause();
|
||||
|
||||
/**
|
||||
* Pauses the task, which lets the thread finish without completing the task.
|
||||
* Tasks are written in the way where they can pause without any issues.
|
||||
* This won't be instant, as this function is applied asynchronous.
|
||||
* It will await the pausing of the task.
|
||||
*/
|
||||
public void awaitPausing();
|
||||
|
||||
/**
|
||||
* Continues the task if it wasn't already completed.
|
||||
* This is done by resubmitting the task to the executor provided.
|
||||
*/
|
||||
public void resume();
|
||||
|
||||
/**
|
||||
* Quality of life function that allows to detect if no cancellation/exception was applied to this task and it completed on its own.
|
||||
* @return true if it was properly completed
|
||||
*/
|
||||
public boolean isSuccessful();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type Specific get method that allows to reduce (un)boxing of primtives.
|
||||
*
|
||||
* Waits if necessary for the computation to complete, and then
|
||||
* retrieves its result.
|
||||
*
|
||||
* @return the computed result as primitive
|
||||
* @throws CancellationException if the computation was cancelled
|
||||
* @throws ExecutionException if the computation threw an exception
|
||||
* @throws InterruptedException if the current thread was interrupted
|
||||
* while waiting
|
||||
*/
|
||||
public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException;
|
||||
|
||||
/**
|
||||
* Waits if necessary for at most the given time for the computation
|
||||
* to complete, and then retrieves its result, if available.
|
||||
*
|
||||
* @param timeout the maximum time to wait
|
||||
* @param unit the time unit of the timeout argument
|
||||
* @return the computed result as primitive
|
||||
* @throws CancellationException if the computation was cancelled
|
||||
* @throws ExecutionException if the computation threw an exception
|
||||
* @throws InterruptedException if the current thread was interrupted while waiting
|
||||
* @throws TimeoutException if the wait timed out
|
||||
*/
|
||||
public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_TYPE get() throws InterruptedException, ExecutionException { return KEY_TO_OBJ(GET_KEY()); }
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_TYPE get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return KEY_TO_OBJ(GET_KEY(timeout, unit)); }
|
||||
#endif
|
||||
package speiger.src.collections.PACKAGE.functions;
|
||||
|
||||
import java.util.concurrent.RunnableFuture;
|
||||
#if !TYPE_OBJECT
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.TimeoutException;
|
||||
#endif
|
||||
|
||||
/**
|
||||
*
|
||||
* A Type Specific Task interface that allows you to keep track of the task that is currently running.<br>
|
||||
* It extends Runnable future and supports said functions but also provides quality of life functions like:<br>
|
||||
*
|
||||
* - isSuccesfull: which allows to detect if the task was completed properly and not interrupted or crashed.
|
||||
* - pause/resume: which allows to pause/resume the task at any moment, making it easier to create thread-safe actions.
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface TASK KEY_GENERIC_TYPE extends RunnableFuture<CLASS_TYPE> {
|
||||
/**
|
||||
* Helper function to detect if the task is currently paused.
|
||||
* @return true if paused
|
||||
*/
|
||||
public boolean isPaused();
|
||||
|
||||
/**
|
||||
* Pauses the task, which lets the thread finish without completing the task.
|
||||
* Tasks are written in the way where they can pause without any issues.
|
||||
* This won't be instant, as this function is applied asynchronous and doesn't check if the thread paused.
|
||||
* So make sure it had the time to pause.
|
||||
*/
|
||||
public void pause();
|
||||
|
||||
/**
|
||||
* Pauses the task, which lets the thread finish without completing the task.
|
||||
* Tasks are written in the way where they can pause without any issues.
|
||||
* This won't be instant, as this function is applied asynchronous.
|
||||
* It will await the pausing of the task.
|
||||
*/
|
||||
public void awaitPausing();
|
||||
|
||||
/**
|
||||
* Continues the task if it wasn't already completed.
|
||||
* This is done by resubmitting the task to the executor provided.
|
||||
*/
|
||||
public void resume();
|
||||
|
||||
/**
|
||||
* Quality of life function that allows to detect if no cancellation/exception was applied to this task and it completed on its own.
|
||||
* @return true if it was properly completed
|
||||
*/
|
||||
public boolean isSuccessful();
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
/**
|
||||
* A Type Specific get method that allows to reduce (un)boxing of primtives.
|
||||
*
|
||||
* Waits if necessary for the computation to complete, and then
|
||||
* retrieves its result.
|
||||
*
|
||||
* @return the computed result as primitive
|
||||
* @throws CancellationException if the computation was cancelled
|
||||
* @throws ExecutionException if the computation threw an exception
|
||||
* @throws InterruptedException if the current thread was interrupted
|
||||
* while waiting
|
||||
*/
|
||||
public KEY_TYPE GET_KEY() throws InterruptedException, ExecutionException;
|
||||
|
||||
/**
|
||||
* Waits if necessary for at most the given time for the computation
|
||||
* to complete, and then retrieves its result, if available.
|
||||
*
|
||||
* @param timeout the maximum time to wait
|
||||
* @param unit the time unit of the timeout argument
|
||||
* @return the computed result as primitive
|
||||
* @throws CancellationException if the computation was cancelled
|
||||
* @throws ExecutionException if the computation threw an exception
|
||||
* @throws InterruptedException if the current thread was interrupted while waiting
|
||||
* @throws TimeoutException if the wait timed out
|
||||
*/
|
||||
public KEY_TYPE GET_KEY(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_TYPE get() throws InterruptedException, ExecutionException { return KEY_TO_OBJ(GET_KEY()); }
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_TYPE get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return KEY_TO_OBJ(GET_KEY(timeout, unit)); }
|
||||
#endif
|
||||
}
|
||||
+133
-133
@@ -1,134 +1,134 @@
|
||||
package speiger.src.collections.PACKAGE.functions.function;
|
||||
|
||||
#if VALUE_BOOLEAN || SAME_TYPE
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
|
||||
* @Type(T)
|
||||
* @ValueType(V)
|
||||
*/
|
||||
@FunctionalInterface
|
||||
#if JDK_FUNCTION
|
||||
public interface FUNCTION KEY_VALUE_GENERIC_TYPE extends JAVA_FUNCTION KEY_VALUE_GENERIC_TYPE
|
||||
#else
|
||||
public interface FUNCTION KEY_VALUE_GENERIC_TYPE
|
||||
#endif
|
||||
{
|
||||
/**
|
||||
* Type Specific get function to reduce boxing/unboxing
|
||||
* @param k the value that should be processed
|
||||
* @return the result of the function
|
||||
*/
|
||||
public VALUE_TYPE APPLY(KEY_TYPE k);
|
||||
|
||||
#if SAME_TYPE
|
||||
/**
|
||||
* Creates a Default function that returns the input provided.
|
||||
* @Type(T)
|
||||
* @return a input returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_SAME_GENERIC_TYPE identity() {
|
||||
return T -> T;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a composed function that first applies the {@code before}
|
||||
* function to its input, and then applies this function to the result.
|
||||
* If evaluation of either function throws an exception, it is relayed to
|
||||
* the caller of the composed function.
|
||||
*
|
||||
* @Type(I)
|
||||
* @param before the function that should be used first
|
||||
* @return a composed function with a different starting function.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION SV_GENERIC_TYPE<I> compose(FUNCTION SK_GENERIC_TYPE<I> before) {
|
||||
Objects.requireNonNull(before);
|
||||
return T -> APPLY(before.APPLY(T));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a composed function that first applies this function to
|
||||
* its input, and then applies the {@code after} function to the result.
|
||||
* If evaluation of either function throws an exception, it is relayed to
|
||||
* the caller of the composed function.
|
||||
*
|
||||
* @Type(I)
|
||||
* @param after the function that should be used last
|
||||
* @return a composed function with a different starting function.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION KS_GENERIC_TYPE<I> andThen(FUNCTION VS_GENERIC_TYPE<I> after) {
|
||||
Objects.requireNonNull(after);
|
||||
return T -> after.APPLY(APPLY(T));
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_BOOLEAN
|
||||
/**
|
||||
* Creates a Always true function that may be useful if you don't need to process information or just want a default.
|
||||
* @Type(T)
|
||||
* @return a default returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysTrue() {
|
||||
return T -> true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a Always false function that may be useful if you don't need to process information or just want a default.
|
||||
* @Type(T)
|
||||
* @return a default returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysFalse() {
|
||||
return T -> false;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type specific and-function helper function that reduces boxing/unboxing
|
||||
* @param other the other function that should be merged with.
|
||||
* @return a function that compares values in a and comparason
|
||||
*/
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE andType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) && other.APPLY(T);
|
||||
}
|
||||
|
||||
#if JDK_FUNCTION
|
||||
@Override
|
||||
@Deprecated
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE and(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) && other.APPLY(T);
|
||||
}
|
||||
|
||||
@Override
|
||||
#else
|
||||
/**
|
||||
* A type specific inverter function
|
||||
* @return the same function but inverts the result
|
||||
*/
|
||||
#endif
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE negate() {
|
||||
return T -> !APPLY(T);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type specific or-function helper function that reduces boxing/unboxing
|
||||
* @param other the other function that should be merged with.
|
||||
* @return a function that compares values in a or comparason
|
||||
*/
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE orType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) || other.APPLY(T);
|
||||
}
|
||||
|
||||
#if JDK_FUNCTION
|
||||
@Override
|
||||
@Deprecated
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE or(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) || other.APPLY(T);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
package speiger.src.collections.PACKAGE.functions.function;
|
||||
|
||||
#if VALUE_BOOLEAN || SAME_TYPE
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* A Type Specific Function interface that reduces boxing/unboxing and fills the gaps of interfaces that are missing.
|
||||
* @Type(T)
|
||||
* @ValueType(V)
|
||||
*/
|
||||
@FunctionalInterface
|
||||
#if JDK_FUNCTION
|
||||
public interface FUNCTION KEY_VALUE_GENERIC_TYPE extends JAVA_FUNCTION KEY_VALUE_GENERIC_TYPE
|
||||
#else
|
||||
public interface FUNCTION KEY_VALUE_GENERIC_TYPE
|
||||
#endif
|
||||
{
|
||||
/**
|
||||
* Type Specific get function to reduce boxing/unboxing
|
||||
* @param k the value that should be processed
|
||||
* @return the result of the function
|
||||
*/
|
||||
public VALUE_TYPE APPLY(KEY_TYPE k);
|
||||
|
||||
#if SAME_TYPE
|
||||
/**
|
||||
* Creates a Default function that returns the input provided.
|
||||
* @Type(T)
|
||||
* @return a input returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_SAME_GENERIC_TYPE identity() {
|
||||
return T -> T;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a composed function that first applies the {@code before}
|
||||
* function to its input, and then applies this function to the result.
|
||||
* If evaluation of either function throws an exception, it is relayed to
|
||||
* the caller of the composed function.
|
||||
*
|
||||
* @Type(I)
|
||||
* @param before the function that should be used first
|
||||
* @return a composed function with a different starting function.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION SV_GENERIC_TYPE<I> compose(FUNCTION SK_GENERIC_TYPE<I> before) {
|
||||
Objects.requireNonNull(before);
|
||||
return T -> APPLY(before.APPLY(T));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a composed function that first applies this function to
|
||||
* its input, and then applies the {@code after} function to the result.
|
||||
* If evaluation of either function throws an exception, it is relayed to
|
||||
* the caller of the composed function.
|
||||
*
|
||||
* @Type(I)
|
||||
* @param after the function that should be used last
|
||||
* @return a composed function with a different starting function.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_VALUE_BRACES<I> FUNCTION KS_GENERIC_TYPE<I> andThen(FUNCTION VS_GENERIC_TYPE<I> after) {
|
||||
Objects.requireNonNull(after);
|
||||
return T -> after.APPLY(APPLY(T));
|
||||
}
|
||||
|
||||
#endif
|
||||
#if VALUE_BOOLEAN
|
||||
/**
|
||||
* Creates a Always true function that may be useful if you don't need to process information or just want a default.
|
||||
* @Type(T)
|
||||
* @return a default returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysTrue() {
|
||||
return T -> true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a Always false function that may be useful if you don't need to process information or just want a default.
|
||||
* @Type(T)
|
||||
* @return a default returning function
|
||||
*/
|
||||
public static GENERIC_KEY_BRACES FUNCTION KEY_GENERIC_TYPE alwaysFalse() {
|
||||
return T -> false;
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type specific and-function helper function that reduces boxing/unboxing
|
||||
* @param other the other function that should be merged with.
|
||||
* @return a function that compares values in a and comparason
|
||||
*/
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE andType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) && other.APPLY(T);
|
||||
}
|
||||
|
||||
#if JDK_FUNCTION
|
||||
@Override
|
||||
@Deprecated
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE and(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) && other.APPLY(T);
|
||||
}
|
||||
|
||||
@Override
|
||||
#else
|
||||
/**
|
||||
* A type specific inverter function
|
||||
* @return the same function but inverts the result
|
||||
*/
|
||||
#endif
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE negate() {
|
||||
return T -> !APPLY(T);
|
||||
}
|
||||
|
||||
/**
|
||||
* A Type specific or-function helper function that reduces boxing/unboxing
|
||||
* @param other the other function that should be merged with.
|
||||
* @return a function that compares values in a or comparason
|
||||
*/
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE orType(FUNCTION KEY_VALUE_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) || other.APPLY(T);
|
||||
}
|
||||
|
||||
#if JDK_FUNCTION
|
||||
@Override
|
||||
@Deprecated
|
||||
public default FUNCTION KEY_VALUE_GENERIC_TYPE or(JAVA_FUNCTION KEY_VALUE_SUPER_GENERIC_TYPE other) {
|
||||
Objects.requireNonNull(other);
|
||||
return T -> APPLY(T) || other.APPLY(T);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
+1199
-1197
File diff suppressed because it is too large
Load Diff
+2190
-2188
File diff suppressed because it is too large
Load Diff
+1378
-1376
File diff suppressed because it is too large
Load Diff
+2526
-2524
File diff suppressed because it is too large
Load Diff
+1513
-1511
File diff suppressed because it is too large
Load Diff
+1555
-1553
File diff suppressed because it is too large
Load Diff
+1512
-1510
File diff suppressed because it is too large
Load Diff
+1510
-1508
File diff suppressed because it is too large
Load Diff
+1407
-1405
File diff suppressed because it is too large
Load Diff
+1457
-1455
File diff suppressed because it is too large
Load Diff
+738
-738
File diff suppressed because it is too large
Load Diff
+963
-963
File diff suppressed because it is too large
Load Diff
+2918
-2916
File diff suppressed because it is too large
Load Diff
+2990
-2988
File diff suppressed because it is too large
Load Diff
+94
-94
@@ -1,95 +1,95 @@
|
||||
package speiger.src.collections.PACKAGE.maps.interfaces;
|
||||
|
||||
import java.util.concurrent.ConcurrentMap;
|
||||
import java.util.function.BiConsumer;
|
||||
import java.util.function.BiFunction;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* A type specific ConcurrentMap interface that reduces boxing/unboxing.
|
||||
* Since the interface adds nothing new. It is there just for completion sake.
|
||||
* @Type(T)
|
||||
* @ValueType(V)
|
||||
*/
|
||||
public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.compute(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.computeIfAbsent(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.computeIfPresent(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
|
||||
MAP.super.forEach(action);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.merge(key, value, mappingFunction);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT && VALUE_OBJECT
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
|
||||
@Override
|
||||
public boolean remove(Object key, Object value);
|
||||
@Override
|
||||
public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
|
||||
|
||||
#else
|
||||
@Primitive
|
||||
@Override
|
||||
public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
|
||||
return MAP.super.getOrDefault(key, defaultValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
|
||||
return MAP.super.putIfAbsent(key, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean remove(Object key, Object value) {
|
||||
return MAP.super.remove(key, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
|
||||
return MAP.super.replace(key, oldValue, newValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
|
||||
return MAP.super.replace(key, value);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
@Deprecated
|
||||
public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
MAP.super.replaceAll(mappingFunction);
|
||||
}
|
||||
package speiger.src.collections.PACKAGE.maps.interfaces;
|
||||
|
||||
import java.util.concurrent.ConcurrentMap;
|
||||
import java.util.function.BiConsumer;
|
||||
import java.util.function.BiFunction;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* A type specific ConcurrentMap interface that reduces boxing/unboxing.
|
||||
* Since the interface adds nothing new. It is there just for completion sake.
|
||||
* @Type(T)
|
||||
* @ValueType(V)
|
||||
*/
|
||||
public interface CONCURRENT_MAP KEY_VALUE_GENERIC_TYPE extends ConcurrentMap<CLASS_TYPE, CLASS_VALUE_TYPE>, MAP KEY_VALUE_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE compute(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.compute(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE computeIfAbsent(CLASS_TYPE key, Function<? super CLASS_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.computeIfAbsent(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE computeIfPresent(CLASS_TYPE key, BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.computeIfPresent(key, mappingFunction);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default void forEach(BiConsumer<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE> action) {
|
||||
MAP.super.forEach(action);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE merge(CLASS_TYPE key, CLASS_VALUE_TYPE value, BiFunction<? super CLASS_VALUE_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
return MAP.super.merge(key, value, mappingFunction);
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT && VALUE_OBJECT
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue);
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value);
|
||||
@Override
|
||||
public boolean remove(Object key, Object value);
|
||||
@Override
|
||||
public boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue);
|
||||
@Override
|
||||
public CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value);
|
||||
|
||||
#else
|
||||
@Primitive
|
||||
@Override
|
||||
public default CLASS_VALUE_TYPE getOrDefault(Object key, CLASS_VALUE_TYPE defaultValue) {
|
||||
return MAP.super.getOrDefault(key, defaultValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Primitive
|
||||
public default CLASS_VALUE_TYPE putIfAbsent(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
|
||||
return MAP.super.putIfAbsent(key, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean remove(Object key, Object value) {
|
||||
return MAP.super.remove(key, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default boolean replace(CLASS_TYPE key, CLASS_VALUE_TYPE oldValue, CLASS_VALUE_TYPE newValue) {
|
||||
return MAP.super.replace(key, oldValue, newValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Deprecated
|
||||
public default CLASS_VALUE_TYPE replace(CLASS_TYPE key, CLASS_VALUE_TYPE value) {
|
||||
return MAP.super.replace(key, value);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
@Deprecated
|
||||
public default void replaceAll(BiFunction<? super CLASS_TYPE, ? super CLASS_VALUE_TYPE, ? extends CLASS_VALUE_TYPE> mappingFunction) {
|
||||
MAP.super.replaceAll(mappingFunction);
|
||||
}
|
||||
}
|
||||
+46
-46
@@ -1,46 +1,46 @@
|
||||
package speiger.src.collections.PACKAGE.queues;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
import java.util.StringJoiner;
|
||||
|
||||
/**
|
||||
* Helper class that implements all the essential methods for the PriorityQueues
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if(obj instanceof PRIORITY_QUEUE) {
|
||||
PRIORITY_QUEUE KEY_GENERIC_TYPE queue = (PRIORITY_QUEUE KEY_GENERIC_TYPE)obj;
|
||||
if(queue.size() != size()) return false;
|
||||
for(int i = 0,m=size();i<m;i++) {
|
||||
if(KEY_EQUALS_NOT(queue.peek(i), peek(i))) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int result = 1;
|
||||
for (int i = 0,m=size();i<m;i++) {
|
||||
result = 31 * result + KEY_TO_HASH(peek(i));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString()
|
||||
{
|
||||
if(isEmpty()) return "[]";
|
||||
StringJoiner joiner = new StringJoiner(", ", "[", "]");
|
||||
for (int i = 0,m=size();i<m;i++) {
|
||||
joiner.add(KEY_TO_STRING(peek(i)));
|
||||
}
|
||||
return joiner.toString();
|
||||
}
|
||||
}
|
||||
package speiger.src.collections.PACKAGE.queues;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
import java.util.StringJoiner;
|
||||
|
||||
/**
|
||||
* Helper class that implements all the essential methods for the PriorityQueues
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_PRIORITY_QUEUE KEY_GENERIC_TYPE implements PRIORITY_QUEUE KEY_GENERIC_TYPE
|
||||
{
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if(obj instanceof PRIORITY_QUEUE) {
|
||||
PRIORITY_QUEUE KEY_GENERIC_TYPE queue = (PRIORITY_QUEUE KEY_GENERIC_TYPE)obj;
|
||||
if(queue.size() != size()) return false;
|
||||
for(int i = 0,m=size();i<m;i++) {
|
||||
if(KEY_EQUALS_NOT(queue.peek(i), peek(i))) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int result = 1;
|
||||
for (int i = 0,m=size();i<m;i++) {
|
||||
result = 31 * result + KEY_TO_HASH(peek(i));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString()
|
||||
{
|
||||
if(isEmpty()) return "[]";
|
||||
StringJoiner joiner = new StringJoiner(", ", "[", "]");
|
||||
for (int i = 0,m=size();i<m;i++) {
|
||||
joiner.add(KEY_TO_STRING(peek(i)));
|
||||
}
|
||||
return joiner.toString();
|
||||
}
|
||||
}
|
||||
|
||||
+195
-194
@@ -1,195 +1,196 @@
|
||||
package speiger.src.collections.PACKAGE.queues;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Comparator;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.function.IntFunction;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.collections.COLLECTION;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
||||
#if QUEUES_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TYPE
|
||||
{
|
||||
/**
|
||||
* @return true if the PriorityQueue is empty
|
||||
*/
|
||||
public default boolean isEmpty() { return size() <= 0; }
|
||||
/**
|
||||
* @return the amount of elements that are stored in the PriorityQueue
|
||||
*/
|
||||
public int size();
|
||||
/**
|
||||
* clears all elements within the PriorityQueue,
|
||||
* this does not resize the backing arrays
|
||||
*/
|
||||
public void clear();
|
||||
|
||||
/**
|
||||
* Method to insert a element into the PriorityQueue
|
||||
* @param e the element that should be inserted
|
||||
*/
|
||||
public void enqueue(KEY_TYPE e);
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE... e) {
|
||||
enqueueAll(e, 0, e.length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
* @param length the amount of elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE[] e, int length) {
|
||||
enqueueAll(e, 0, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
* @param offset the offset where in the array should be started
|
||||
* @param length the amount of elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE[] e, int offset, int length) {
|
||||
for(int i = 0;i<length;i++)
|
||||
enqueue(e[i+offset]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param c the elements that should be inserted from the Collection
|
||||
*/
|
||||
public default void enqueueAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
enqueue(iter.NEXT());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* This method exists to add support for Java Collections to make it more useable
|
||||
* @param c the elements that should be inserted from the Collection
|
||||
*/
|
||||
public default void enqueueAll(Collection<? extends CLASS_TYPE> c) {
|
||||
for(Iterator<? extends CLASS_TYPE> iter = c.iterator();iter.hasNext();)
|
||||
enqueue(iter.next());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Method to extract a element from the PriorityQueue
|
||||
* @return a element from the Queue
|
||||
* @throws java.util.NoSuchElementException if no element is present
|
||||
*/
|
||||
public KEY_TYPE dequeue();
|
||||
|
||||
/**
|
||||
* Peeking function to see whats inside the queue.
|
||||
* @param index of the element that is requested to be viewed.
|
||||
* @return the element that is requested
|
||||
*/
|
||||
public KEY_TYPE peek(int index);
|
||||
/**
|
||||
* Shows the element that is to be returned next
|
||||
* @return the first element in the Queue
|
||||
*/
|
||||
public default KEY_TYPE first() { return peek(0); }
|
||||
|
||||
/**
|
||||
* Removes the first found element in the queue
|
||||
* @param e the element that should be removed
|
||||
* @return if a searched element was removed
|
||||
*/
|
||||
public boolean removeFirst(KEY_TYPE e);
|
||||
/**
|
||||
* Removes the last found element in the queue
|
||||
* @param e the element that should be removed
|
||||
* @return if a searched element was removed
|
||||
*/
|
||||
public boolean removeLast(KEY_TYPE e);
|
||||
|
||||
/**
|
||||
* Allows to notify the Queue to be revalidate its data
|
||||
*/
|
||||
public void onChanged();
|
||||
|
||||
/**
|
||||
* A Function that does a shallow clone of the PriorityQueue itself.
|
||||
* This function is more optimized then a copy constructor since the PriorityQueue does not have to be unsorted/resorted.
|
||||
* It can be compared to Cloneable but with less exception risk
|
||||
* @return a Shallow Copy of the PriorityQueue
|
||||
* @note Wrappers and view PriorityQueues will not support this feature
|
||||
*/
|
||||
public PRIORITY_QUEUE KEY_GENERIC_TYPE copy();
|
||||
|
||||
/**
|
||||
* @return the sorter of the Queue, can be null
|
||||
*/
|
||||
public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator();
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* @return draining iterator of the PriorityQueue
|
||||
*/
|
||||
public ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#endif
|
||||
#if QUEUES_FEATURE
|
||||
/**
|
||||
* Creates a Wrapped PriorityQueue that is Synchronized
|
||||
* @return a new PriorityQueue that is synchronized
|
||||
* @see PRIORITY_QUEUES#synchronize
|
||||
*/
|
||||
public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped PriorityQueue that is Synchronized
|
||||
* @param mutex is the controller of the synchronization block
|
||||
* @return a new PriorityQueue Wrapper that is synchronized
|
||||
* @see PRIORITY_QUEUES#synchronize
|
||||
*/
|
||||
public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A method to drop the contents of the Queue without clearing the queue
|
||||
* @Type(E)
|
||||
* @return the contents of the queue into a seperate array.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY() { return TO_ARRAY(NEW_SPECIAL_KEY_ARRAY(size())); }
|
||||
/**
|
||||
* A method to drop the contents of the Queue without clearing the queue
|
||||
* @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
|
||||
* @Type(E)
|
||||
* @return the contents of the queue into a seperate array.
|
||||
* @note if the Type is generic then a Object Array is created instead of a Type Array
|
||||
*/
|
||||
public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that simplifies the process of creating a new Array.
|
||||
* @param action the array creation function
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
return TO_ARRAY(action.apply(size()));
|
||||
}
|
||||
#endif
|
||||
package speiger.src.collections.PACKAGE.queues;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Comparator;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.function.IntFunction;
|
||||
#else
|
||||
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
||||
#endif
|
||||
import speiger.src.collections.PACKAGE.collections.COLLECTION;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERABLE;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
||||
#if QUEUES_FEATURE
|
||||
import speiger.src.collections.PACKAGE.utils.PRIORITY_QUEUES;
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.
|
||||
* @Type(T)
|
||||
*/
|
||||
public interface PRIORITY_QUEUE KEY_GENERIC_TYPE extends ITERABLE KEY_GENERIC_TYPE
|
||||
{
|
||||
/**
|
||||
* @return true if the PriorityQueue is empty
|
||||
*/
|
||||
public default boolean isEmpty() { return size() <= 0; }
|
||||
/**
|
||||
* @return the amount of elements that are stored in the PriorityQueue
|
||||
*/
|
||||
public int size();
|
||||
/**
|
||||
* clears all elements within the PriorityQueue,
|
||||
* this does not resize the backing arrays
|
||||
*/
|
||||
public void clear();
|
||||
|
||||
/**
|
||||
* Method to insert a element into the PriorityQueue
|
||||
* @param e the element that should be inserted
|
||||
*/
|
||||
public void enqueue(KEY_TYPE e);
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE... e) {
|
||||
enqueueAll(e, 0, e.length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
* @param length the amount of elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE[] e, int length) {
|
||||
enqueueAll(e, 0, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param e the elements that should be inserted
|
||||
* @param offset the offset where in the array should be started
|
||||
* @param length the amount of elements that should be inserted
|
||||
*/
|
||||
public default void enqueueAll(KEY_TYPE[] e, int offset, int length) {
|
||||
for(int i = 0;i<length;i++)
|
||||
enqueue(e[i+offset]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* @param c the elements that should be inserted from the Collection
|
||||
*/
|
||||
public default void enqueueAll(COLLECTION KEY_GENERIC_TYPE c) {
|
||||
for(ITERATOR KEY_GENERIC_TYPE iter = c.iterator();iter.hasNext();)
|
||||
enqueue(iter.NEXT());
|
||||
}
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* Method to mass insert elements into the PriorityQueue
|
||||
* This method exists to add support for Java Collections to make it more useable
|
||||
* @param c the elements that should be inserted from the Collection
|
||||
*/
|
||||
public default void enqueueAll(Collection<? extends CLASS_TYPE> c) {
|
||||
for(Iterator<? extends CLASS_TYPE> iter = c.iterator();iter.hasNext();)
|
||||
enqueue(iter.next());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Method to extract a element from the PriorityQueue
|
||||
* @return a element from the Queue
|
||||
* @throws java.util.NoSuchElementException if no element is present
|
||||
*/
|
||||
public KEY_TYPE dequeue();
|
||||
|
||||
/**
|
||||
* Peeking function to see whats inside the queue.
|
||||
* @param index of the element that is requested to be viewed.
|
||||
* @return the element that is requested
|
||||
*/
|
||||
public KEY_TYPE peek(int index);
|
||||
/**
|
||||
* Shows the element that is to be returned next
|
||||
* @return the first element in the Queue
|
||||
*/
|
||||
public default KEY_TYPE first() { return peek(0); }
|
||||
|
||||
/**
|
||||
* Removes the first found element in the queue
|
||||
* @param e the element that should be removed
|
||||
* @return if a searched element was removed
|
||||
*/
|
||||
public boolean removeFirst(KEY_TYPE e);
|
||||
/**
|
||||
* Removes the last found element in the queue
|
||||
* @param e the element that should be removed
|
||||
* @return if a searched element was removed
|
||||
*/
|
||||
public boolean removeLast(KEY_TYPE e);
|
||||
|
||||
/**
|
||||
* Allows to notify the Queue to be revalidate its data
|
||||
*/
|
||||
public void onChanged();
|
||||
|
||||
/**
|
||||
* A Function that does a shallow clone of the PriorityQueue itself.
|
||||
* This function is more optimized then a copy constructor since the PriorityQueue does not have to be unsorted/resorted.
|
||||
* It can be compared to Cloneable but with less exception risk
|
||||
* @return a Shallow Copy of the PriorityQueue
|
||||
* @note Wrappers and view PriorityQueues will not support this feature
|
||||
*/
|
||||
public PRIORITY_QUEUE KEY_GENERIC_TYPE copy();
|
||||
|
||||
/**
|
||||
* @return the sorter of the Queue, can be null
|
||||
*/
|
||||
public COMPARATOR KEY_SUPER_GENERIC_TYPE comparator();
|
||||
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* @return draining iterator of the PriorityQueue
|
||||
*/
|
||||
public ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
|
||||
#endif
|
||||
#if QUEUES_FEATURE
|
||||
/**
|
||||
* Creates a Wrapped PriorityQueue that is Synchronized
|
||||
* @return a new PriorityQueue that is synchronized
|
||||
* @see PRIORITY_QUEUES#synchronize
|
||||
*/
|
||||
public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue() { return PRIORITY_QUEUES.synchronize(this); }
|
||||
|
||||
/**
|
||||
* Creates a Wrapped PriorityQueue that is Synchronized
|
||||
* @param mutex is the controller of the synchronization block
|
||||
* @return a new PriorityQueue Wrapper that is synchronized
|
||||
* @see PRIORITY_QUEUES#synchronize
|
||||
*/
|
||||
public default PRIORITY_QUEUE KEY_GENERIC_TYPE synchronizeQueue(Object mutex) { return PRIORITY_QUEUES.synchronize(this, mutex); }
|
||||
|
||||
#endif
|
||||
/**
|
||||
* A method to drop the contents of the Queue without clearing the queue
|
||||
* @Type(E)
|
||||
* @return the contents of the queue into a seperate array.
|
||||
*/
|
||||
public default GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY() { return TO_ARRAY(NEW_SPECIAL_KEY_ARRAY(size())); }
|
||||
/**
|
||||
* A method to drop the contents of the Queue without clearing the queue
|
||||
* @param input where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
|
||||
* @Type(E)
|
||||
* @return the contents of the queue into a seperate array.
|
||||
* @note if the Type is generic then a Object Array is created instead of a Type Array
|
||||
*/
|
||||
public GENERIC_SPECIAL_KEY_BRACES<E> KEY_SPECIAL_TYPE[] TO_ARRAY(KEY_SPECIAL_TYPE[] input);
|
||||
#if TYPE_OBJECT
|
||||
/**
|
||||
* A Helper function that simplifies the process of creating a new Array.
|
||||
* @param action the array creation function
|
||||
* @param <E> the returning arrayType
|
||||
* @return an array containing all of the elements in this collection
|
||||
* @see Collection#toArray(Object[])
|
||||
*/
|
||||
default <E> E[] TO_ARRAY(IntFunction<E[]> action) {
|
||||
return TO_ARRAY(action.apply(size()));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
+50
-50
@@ -1,50 +1,50 @@
|
||||
package speiger.src.collections.PACKAGE.sets;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
import java.util.Set;
|
||||
|
||||
import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
||||
|
||||
/**
|
||||
* Abstract Type Specific Set that reduces boxing/unboxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
||||
{
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public abstract ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
@Override
|
||||
public ABSTRACT_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int hashCode = 0;
|
||||
ITERATOR KEY_GENERIC_TYPE i = iterator();
|
||||
while(i.hasNext())
|
||||
hashCode += KEY_TO_HASH(i.NEXT());
|
||||
return hashCode;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (o == this)
|
||||
return true;
|
||||
if (!(o instanceof Set))
|
||||
return false;
|
||||
Set<?> l = (Set<?>)o;
|
||||
if(l.size() != size()) return false;
|
||||
try {
|
||||
return containsAll(l);
|
||||
} catch (ClassCastException | NullPointerException unused) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
package speiger.src.collections.PACKAGE.sets;
|
||||
|
||||
#if TYPE_OBJECT
|
||||
import java.util.Objects;
|
||||
#endif
|
||||
import java.util.Set;
|
||||
|
||||
import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
||||
|
||||
/**
|
||||
* Abstract Type Specific Set that reduces boxing/unboxing
|
||||
* @Type(T)
|
||||
*/
|
||||
public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
||||
{
|
||||
#if TYPE_OBJECT
|
||||
@Override
|
||||
public KEY_TYPE addOrGet(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public abstract ITERATOR KEY_GENERIC_TYPE iterator();
|
||||
@Override
|
||||
public ABSTRACT_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int hashCode = 0;
|
||||
ITERATOR KEY_GENERIC_TYPE i = iterator();
|
||||
while(i.hasNext())
|
||||
hashCode += KEY_TO_HASH(i.NEXT());
|
||||
return hashCode;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (o == this)
|
||||
return true;
|
||||
if (!(o instanceof Set))
|
||||
return false;
|
||||
Set<?> l = (Set<?>)o;
|
||||
if(l.size() != size()) return false;
|
||||
try {
|
||||
return containsAll(l);
|
||||
} catch (ClassCastException | NullPointerException unused) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1655
-1655
File diff suppressed because it is too large
Load Diff
+1036
-1037
File diff suppressed because it is too large
Load Diff
+587
-587
File diff suppressed because it is too large
Load Diff
+1119
-1119
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+1179
-1179
File diff suppressed because it is too large
Load Diff
+28
-28
@@ -1,28 +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;
|
||||
}
|
||||
}
|
||||
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
-384
@@ -1,384 +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;
|
||||
}
|
||||
}
|
||||
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
-140
@@ -1,140 +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();
|
||||
}
|
||||
}
|
||||
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
-38
@@ -1,38 +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();
|
||||
}
|
||||
}
|
||||
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
-60
@@ -1,60 +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;
|
||||
}
|
||||
|
||||
}
|
||||
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
-116
@@ -1,116 +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;
|
||||
}
|
||||
}
|
||||
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
-88
@@ -1,88 +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));
|
||||
}
|
||||
}
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
+303
-303
@@ -1,304 +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;
|
||||
}
|
||||
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
-79
@@ -1,79 +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);
|
||||
}
|
||||
}
|
||||
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
-55
@@ -1,55 +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);
|
||||
}
|
||||
}
|
||||
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
-90
@@ -1,90 +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));
|
||||
}
|
||||
}
|
||||
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
-30
@@ -1,30 +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);
|
||||
}
|
||||
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
-16
@@ -1,16 +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
|
||||
}
|
||||
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
-13
@@ -1,13 +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);
|
||||
}
|
||||
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
-13
@@ -1,13 +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);
|
||||
}
|
||||
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
-30
@@ -1,30 +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);
|
||||
}
|
||||
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
-15
@@ -1,15 +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);
|
||||
}
|
||||
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
-38
@@ -1,38 +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();
|
||||
}
|
||||
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
-46
@@ -1,46 +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())
|
||||
);
|
||||
}
|
||||
}
|
||||
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
-13
@@ -1,13 +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);
|
||||
}
|
||||
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
-25
@@ -1,25 +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();
|
||||
}
|
||||
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();
|
||||
}
|
||||
|
||||
+313
-313
@@ -1,314 +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
|
||||
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
|
||||
}
|
||||
+81
-81
@@ -1,82 +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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
+220
-220
@@ -1,221 +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
|
||||
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
-173
@@ -1,173 +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);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
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
-550
File diff suppressed because it is too large
Load Diff
+933
-933
File diff suppressed because it is too large
Load Diff
+200
-200
@@ -1,200 +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]); }
|
||||
}
|
||||
}
|
||||
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]); }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,92 +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();
|
||||
}
|
||||
};
|
||||
}
|
||||
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
-28
@@ -1,28 +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();
|
||||
}
|
||||
|
||||
}
|
||||
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();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
+187
-187
@@ -1,188 +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));
|
||||
}
|
||||
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
-27
@@ -1,27 +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()));
|
||||
}
|
||||
}
|
||||
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()));
|
||||
}
|
||||
}
|
||||
|
||||
+38
-38
@@ -1,39 +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);
|
||||
}
|
||||
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
-81
@@ -1,81 +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;
|
||||
}
|
||||
}
|
||||
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
-14
@@ -1,14 +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;
|
||||
}
|
||||
}
|
||||
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
-243
@@ -1,243 +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();
|
||||
}
|
||||
}
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
+150
-150
@@ -1,151 +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
|
||||
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
-102
@@ -1,102 +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();
|
||||
}
|
||||
}
|
||||
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
-64
@@ -1,64 +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
|
||||
}
|
||||
}
|
||||
}
|
||||
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
-68
@@ -1,68 +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
|
||||
}
|
||||
}
|
||||
}
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+164
-164
@@ -1,165 +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
|
||||
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
-45
@@ -1,45 +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())));
|
||||
}
|
||||
|
||||
}
|
||||
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
-42
@@ -1,42 +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)));
|
||||
}
|
||||
}
|
||||
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
-27
@@ -1,27 +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
|
||||
}
|
||||
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
-38
@@ -1,38 +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
|
||||
}
|
||||
}
|
||||
}
|
||||
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
-24
@@ -1,24 +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?"));
|
||||
}
|
||||
}
|
||||
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
-55
@@ -1,55 +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);
|
||||
}
|
||||
}
|
||||
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
-161
@@ -1,161 +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) {
|
||||
}
|
||||
}
|
||||
}
|
||||
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
-153
@@ -1,153 +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()));
|
||||
}
|
||||
}
|
||||
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()));
|
||||
}
|
||||
}
|
||||
|
||||
+118
-118
@@ -1,119 +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()));
|
||||
}
|
||||
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
-337
@@ -1,337 +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) {
|
||||
}
|
||||
}
|
||||
}
|
||||
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
-59
@@ -1,59 +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
|
||||
}
|
||||
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
-116
@@ -1,116 +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));
|
||||
}
|
||||
}
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
+46
-46
@@ -1,47 +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())));
|
||||
}
|
||||
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
-24
@@ -1,24 +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));
|
||||
}
|
||||
}
|
||||
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
-52
@@ -1,52 +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;
|
||||
}
|
||||
}
|
||||
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
-43
@@ -1,43 +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())));
|
||||
}
|
||||
}
|
||||
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
-25
@@ -1,25 +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);
|
||||
}
|
||||
}
|
||||
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
-132
@@ -1,132 +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
|
||||
}
|
||||
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
-107
@@ -1,107 +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())));
|
||||
}
|
||||
}
|
||||
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
-19
@@ -1,19 +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);
|
||||
}
|
||||
}
|
||||
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
-78
@@ -1,78 +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
|
||||
}
|
||||
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
-43
@@ -1,43 +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
|
||||
}
|
||||
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
-60
@@ -1,60 +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
|
||||
}
|
||||
}
|
||||
}
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+193
-193
@@ -1,194 +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
|
||||
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
-167
@@ -1,167 +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
|
||||
}
|
||||
}
|
||||
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
-155
@@ -1,155 +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
|
||||
}
|
||||
}
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user