diff --git a/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverrideInjector.java b/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverrideInjector.java index a21d2dbce..7ac5dba77 100644 --- a/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverrideInjector.java +++ b/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverrideInjector.java @@ -105,7 +105,7 @@ public class OverrideInjector } // make sure the override has a valid priority - if (dependencyImplementation.getPriority() < MIN_NON_CORE_OVERRIDE_PRIORITY) + else if (dependencyImplementation.getPriority() < MIN_NON_CORE_OVERRIDE_PRIORITY) { throw new IllegalArgumentException("Invalid priority value [" + dependencyImplementation.getPriority() + "], override priorities must be [" + MIN_NON_CORE_OVERRIDE_PRIORITY + "] or greater."); } diff --git a/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverridePriorityListContainer.java b/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverridePriorityListContainer.java index cead36640..faefcc8a9 100644 --- a/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverridePriorityListContainer.java +++ b/core/src/main/java/com/seibel/lod/core/handlers/dependencyInjection/OverridePriorityListContainer.java @@ -58,7 +58,7 @@ public class OverridePriorityListContainer implements IBindable } public ICoreDhApiOverrideable getOverrideWithHighestPriority() { - if (this.overridePairList.get(0) != null) + if (this.overridePairList.size() != 0) { return this.overridePairList.get(0).override; } @@ -96,8 +96,8 @@ public class OverridePriorityListContainer implements IBindable // utils // - /** sort the list so the lowest priority item is first in the list */ - private void sortList() { this.overridePairList.sort((x,y) -> Integer.compare(x.priority, y.priority)); } + /** sort the list so the highest priority item is first in the list */ + private void sortList() { this.overridePairList.sort((x,y) -> Integer.compare(y.priority, x.priority)); } diff --git a/core/src/test/java/testItems/overrideInjection/objects/OverrideTestPrimary.java b/core/src/test/java/testItems/overrideInjection/objects/OverrideTestPrimary.java index 221d37cd1..947f3ee74 100644 --- a/core/src/test/java/testItems/overrideInjection/objects/OverrideTestPrimary.java +++ b/core/src/test/java/testItems/overrideInjection/objects/OverrideTestPrimary.java @@ -11,6 +11,8 @@ import testItems.overrideInjection.interfaces.IOverrideTest; */ public class OverrideTestPrimary implements IOverrideTest { + public static int PRIORITY = OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY; + public static int VALUE = 3; @@ -18,6 +20,6 @@ public class OverrideTestPrimary implements IOverrideTest public int getValue() { return VALUE; } @Override - public int getPriority() { return OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY; } + public int getPriority() { return PRIORITY; } } diff --git a/core/src/test/java/testItems/worldGeneratorInjection/objects/LevelWrapperTest.java b/core/src/test/java/testItems/worldGeneratorInjection/objects/LevelWrapperTest.java index af5668288..6a34df382 100644 --- a/core/src/test/java/testItems/worldGeneratorInjection/objects/LevelWrapperTest.java +++ b/core/src/test/java/testItems/worldGeneratorInjection/objects/LevelWrapperTest.java @@ -1,29 +1,25 @@ package testItems.worldGeneratorInjection.objects; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.wrappers.world.ICoreDhApiLevelWrapper; + /** * Stub implementation of a Level wrapper for basic unit testing. * * @author James Seibel - * @version 2022-8-23 + * @version 2022-9-8 */ -//public class LevelWrapperTest implements IDhApiLevelWrapper -//{ -// @Override -// public Object getWrappedMcObject_UNSAFE() { return null; } -// -// @Override -// public IDhApiDimensionTypeWrapper getDimensionType() { return null; } -// -// @Override -// public EDhApiLevelType getLevelType() { return EDhApiLevelType.UNKNOWN; } -// -// @Override -// public boolean hasCeiling() { return false; } -// -// @Override -// public boolean hasSkyLight() { return false; } -// -// @Override -// public int getHeight() { return 0; } -// -//} +public class LevelWrapperTest implements ICoreDhApiLevelWrapper +{ + @Override + public Object getWrappedMcObject_UNSAFE() { return null; } + + @Override + public boolean hasCeiling() { return false; } + + @Override + public boolean hasSkyLight() { return false; } + + @Override + public int getHeight() { return 0; } + +} diff --git a/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestCore.java b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestCore.java index 4773f7533..4ce35da3a 100644 --- a/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestCore.java +++ b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestCore.java @@ -1,7 +1,11 @@ package testItems.worldGeneratorInjection.objects; -import com.seibel.lod.core.api.external.coreImplementations.enums.worldGeneration.EDhApiWorldGenThreadMode; -import com.seibel.lod.core.api.external.coreImplementations.enums.worldGeneration.EDhApiWorldGenerationStep; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.override.worldGenerator.ICoreDhApiWorldGenerator; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.wrappers.world.ICoreDhApiLevelWrapper; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenThreadMode; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenerationStep; +import com.seibel.lod.core.handlers.dependencyInjection.OverrideInjector; +import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper; /** * Dummy test implementation object for world generator injection unit tests. @@ -9,31 +13,32 @@ import com.seibel.lod.core.api.external.coreImplementations.enums.worldGeneratio * @author James Seibel * @version 2022-7-26 */ -//public class WorldGeneratorTestCore implements IDhApiWorldGenerator -//{ -// public static EDhApiWorldGenThreadMode THREAD_MODE = EDhApiWorldGenThreadMode.SERVER_THREAD; -// -// -// //==============// -// // IOverridable // -// //==============// -// -// @Override -// public EDhApiOverridePriority getOverrideType() { return EDhApiOverridePriority.CORE; } -// -// -// -// //======================// -// // IDhApiWorldGenerator // -// //======================// -// -// @Override -// public EDhApiWorldGenThreadMode getThreadingMode() { return THREAD_MODE; } -// -// @Override -// public IDhApiChunkWrapper generateChunk(int chunkPosX, int chunkPosZ, IDhApiLevelWrapper serverLevelWrapper, EDhApiWorldGenerationStep maxStepToGenerate) -// { -// // not necessary for testing -// return null; -// } -//} +public class WorldGeneratorTestCore implements ICoreDhApiWorldGenerator +{ + public static EWorldGenThreadMode THREAD_MODE = EWorldGenThreadMode.SINGLE_THREADED; + + + //==============// + // IOverridable // + //==============// + + @Override + public int getPriority() { return OverrideInjector.CORE_PRIORITY; } + + + + //======================// + // IDhApiWorldGenerator // + //======================// + + @Override + public EWorldGenThreadMode getCoreThreadingMode() { return THREAD_MODE; } + + @Override + public IChunkWrapper generateCoreChunk(int chunkPosX, int chunkPosZ, ICoreDhApiLevelWrapper serverLevelWrapper, EWorldGenerationStep maxStepToGenerate) + { + // not necessary for testing + return null; + } + +} diff --git a/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestPrimary.java b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestPrimary.java index 0cafb2bd4..5127710ca 100644 --- a/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestPrimary.java +++ b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestPrimary.java @@ -1,40 +1,45 @@ package testItems.worldGeneratorInjection.objects; import com.seibel.lod.core.api.external.coreImplementations.interfaces.override.worldGenerator.ICoreDhApiWorldGenerator; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.wrappers.world.ICoreDhApiLevelWrapper; import com.seibel.lod.core.enums.worldGeneration.EWorldGenThreadMode; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenerationStep; import com.seibel.lod.core.handlers.dependencyInjection.OverrideInjector; +import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper; /** * Dummy test implementation object for world generator injection unit tests. * * @author James Seibel - * @version 2022-7-26 + * @version 2022-8-9 */ -//public class WorldGeneratorTestPrimary implements ICoreDhApiWorldGenerator -//{ -// public static EWorldGenThreadMode THREAD_MODE = EWorldGenThreadMode.MULTI_THREADED; -// -// -// //==============// -// // IOverridable // -// //==============// -// -// @Override -// public int getOverridePriority() { return OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY; } -// -// -// -// //======================// -// // IDhApiWorldGenerator // -// //======================// -// -// @Override -// public EDhApiWorldGenThreadMode getThreadingMode() { return THREAD_MODE; } -// -// @Override -// public IDhApiChunkWrapper generateChunk(int chunkPosX, int chunkPosZ, IDhApiLevelWrapper serverLevelWrapper, EDhApiWorldGenerationStep maxStepToGenerate) -// { -// // not necessary for testing -// return null; -// } -//} +public class WorldGeneratorTestPrimary implements ICoreDhApiWorldGenerator +{ + public static int PRIORITY = OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY + 5; + public static EWorldGenThreadMode THREAD_MODE = EWorldGenThreadMode.MULTI_THREADED; + + + //==============// + // IOverridable // + //==============// + + @Override + public int getPriority() { return PRIORITY; } + + + + //======================// + // IDhApiWorldGenerator // + //======================// + + @Override + public EWorldGenThreadMode getCoreThreadingMode() { return THREAD_MODE; } + + @Override + public IChunkWrapper generateCoreChunk(int chunkPosX, int chunkPosZ, ICoreDhApiLevelWrapper serverLevelWrapper, EWorldGenerationStep maxStepToGenerate) + { + // not necessary for testing + return null; + } + +} diff --git a/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestSecondary.java b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestSecondary.java new file mode 100644 index 000000000..bf3b14bcc --- /dev/null +++ b/core/src/test/java/testItems/worldGeneratorInjection/objects/WorldGeneratorTestSecondary.java @@ -0,0 +1,45 @@ +package testItems.worldGeneratorInjection.objects; + +import com.seibel.lod.core.api.external.coreImplementations.interfaces.override.worldGenerator.ICoreDhApiWorldGenerator; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.wrappers.world.ICoreDhApiLevelWrapper; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenThreadMode; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenerationStep; +import com.seibel.lod.core.handlers.dependencyInjection.OverrideInjector; +import com.seibel.lod.core.wrapperInterfaces.chunk.IChunkWrapper; + +/** + * Dummy test implementation object for world generator injection unit tests. + * + * @author James Seibel + * @version 2022-8-9 + */ +public class WorldGeneratorTestSecondary implements ICoreDhApiWorldGenerator +{ + public static int PRIORITY = OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY; + public static EWorldGenThreadMode THREAD_MODE = EWorldGenThreadMode.SERVER_THREAD; + + + //==============// + // IOverridable // + //==============// + + @Override + public int getPriority() { return PRIORITY; } + + + + //======================// + // IDhApiWorldGenerator // + //======================// + + @Override + public EWorldGenThreadMode getCoreThreadingMode() { return THREAD_MODE; } + + @Override + public IChunkWrapper generateCoreChunk(int chunkPosX, int chunkPosZ, ICoreDhApiLevelWrapper serverLevelWrapper, EWorldGenerationStep maxStepToGenerate) + { + // not necessary for testing + return null; + } + +} diff --git a/core/src/test/java/tests/DependencyInjectorTest.java b/core/src/test/java/tests/DependencyInjectorTest.java index 2dd488dc8..a0dbe16cc 100644 --- a/core/src/test/java/tests/DependencyInjectorTest.java +++ b/core/src/test/java/tests/DependencyInjectorTest.java @@ -1,5 +1,8 @@ package tests; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.override.worldGenerator.ICoreDhApiWorldGenerator; +import com.seibel.lod.core.api.external.coreImplementations.interfaces.wrappers.world.ICoreDhApiLevelWrapper; +import com.seibel.lod.core.enums.worldGeneration.EWorldGenThreadMode; import com.seibel.lod.core.handlers.dependencyInjection.*; import org.junit.Assert; @@ -7,11 +10,16 @@ import org.junit.Test; import testItems.eventInjection.abstractObjects.DhApiTestEvent; import testItems.eventInjection.objects.DhTestEvent; import testItems.eventInjection.objects.DhTestEventAlt; +import testItems.overrideInjection.interfaces.IOverrideTest; +import testItems.overrideInjection.objects.OverrideTestAssembly; +import testItems.overrideInjection.objects.OverrideTestCore; +import testItems.overrideInjection.objects.OverrideTestPrimary; import testItems.singletonInjection.interfaces.ISingletonTestOne; import testItems.singletonInjection.interfaces.ISingletonTestTwo; import testItems.singletonInjection.objects.ConcreteSingletonTestBoth; import testItems.singletonInjection.objects.ConcreteSingletonTestOne; import testItems.singletonInjection.objects.ConcreteSingletonTestTwo; +import testItems.worldGeneratorInjection.objects.*; import java.util.ArrayList; @@ -149,175 +157,175 @@ public class DependencyInjectorTest } -// @Test -// public void testOverrideInjection() -// { -// OverrideInjector TEST_INJECTOR = new OverrideInjector(OverrideTestAssembly.getPackagePath(2)); -// OverrideInjector CORE_INJECTOR = new OverrideInjector(); -// -// -// // pre-dependency setup -// Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get(IOverrideTest.class)); -// Assert.assertNull("Nothing should have been bound.", CORE_INJECTOR.get(IOverrideTest.class)); -// -// -// // variables to use later -// IOverrideTest override; -// OverrideTestCore coreOverride = new OverrideTestCore(); -// OverrideTestPrimary primaryOverride = new OverrideTestPrimary(); -// -// -// // core override binding -// try { TEST_INJECTOR.bind(IOverrideTest.class, coreOverride); } catch (IllegalArgumentException e) { Assert.fail("Core override should be bindable for test package injector."); } -// -// try -// { -// CORE_INJECTOR.bind(IOverrideTest.class, coreOverride); -// Assert.fail("Core override should not be bindable for core package injector."); -// } -// catch (IllegalArgumentException e) { /* this exception should be thrown */ } -// -// -// // core override -// Assert.assertNotNull("Test injector should've bound core override.", TEST_INJECTOR.get(IOverrideTest.class)); -// Assert.assertNull("Core injector should not have bound core override.", CORE_INJECTOR.get(IOverrideTest.class)); -// // priority gets -// Assert.assertNotNull("Core override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.CORE_PRIORITY)); -// Assert.assertNull("Non-core override should not be bound yet.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.CORE_PRIORITY)); -// // standard get -// override = TEST_INJECTOR.get(IOverrideTest.class); -// Assert.assertEquals("Override returned incorrect override type.", override.getPriority(), OverrideInjector.CORE_PRIORITY); -// Assert.assertEquals("Incorrect override object returned.", override.getValue(), OverrideTestCore.VALUE); -// -// -// // default override -// TEST_INJECTOR.bind(IOverrideTest.class, primaryOverride); -// // priority gets -// Assert.assertNotNull("Test injector should've bound secondary override.", TEST_INJECTOR.get(IOverrideTest.class)); -// Assert.assertNotNull("Core override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.CORE_PRIORITY)); -// Assert.assertNotNull("Secondary override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY)); -// // standard get -// override = TEST_INJECTOR.get(IOverrideTest.class); -// Assert.assertEquals("Override returned incorrect override type.", override.getPriority(), OverrideInjector.DEFAULT_NON_CORE_OVERRIDE_PRIORITY); -// Assert.assertEquals("Incorrect override object returned.", override.getValue(), OverrideTestPrimary.VALUE); -// -// -// // in-line get -// // (make sure the returned type is correct and compiles, the actual value doesn't matter) -// TEST_INJECTOR.get(IOverrideTest.class).getValue(); -// -// } + @Test + public void testOverrideInjection() + { + OverrideInjector TEST_INJECTOR = new OverrideInjector(OverrideTestAssembly.getPackagePath(2)); + OverrideInjector CORE_INJECTOR = new OverrideInjector(); + + + // pre-dependency setup + Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get(IOverrideTest.class)); + Assert.assertNull("Nothing should have been bound.", CORE_INJECTOR.get(IOverrideTest.class)); + + + // variables to use later + IOverrideTest override; + OverrideTestCore coreOverride = new OverrideTestCore(); + OverrideTestPrimary primaryOverride = new OverrideTestPrimary(); + + + // core override binding + try { TEST_INJECTOR.bind(IOverrideTest.class, coreOverride); } catch (IllegalArgumentException e) { Assert.fail("Core override should be bindable for test package injector."); } + + try + { + CORE_INJECTOR.bind(IOverrideTest.class, coreOverride); + Assert.fail("Core override should not be bindable for core package injector."); + } + catch (IllegalArgumentException e) { /* this exception should be thrown */ } + + + // core override + Assert.assertNotNull("Test injector should've bound core override.", TEST_INJECTOR.get(IOverrideTest.class)); + Assert.assertNull("Core injector should not have bound core override.", CORE_INJECTOR.get(IOverrideTest.class)); + // priority gets + Assert.assertNotNull("Core override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.CORE_PRIORITY)); + Assert.assertNull("Non-core override should not be bound yet.", TEST_INJECTOR.get(IOverrideTest.class, OverrideTestPrimary.PRIORITY)); + // standard get + override = TEST_INJECTOR.get(IOverrideTest.class); + Assert.assertEquals("Override returned incorrect override type.", override.getPriority(), OverrideInjector.CORE_PRIORITY); + Assert.assertEquals("Incorrect override object returned.", override.getValue(), OverrideTestCore.VALUE); + + + // default override + TEST_INJECTOR.bind(IOverrideTest.class, primaryOverride); + // priority gets + Assert.assertNotNull("Test injector should've bound secondary override.", TEST_INJECTOR.get(IOverrideTest.class)); + Assert.assertNotNull("Core override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideInjector.CORE_PRIORITY)); + Assert.assertNotNull("Secondary override should be bound.", TEST_INJECTOR.get(IOverrideTest.class, OverrideTestPrimary.PRIORITY)); + // standard get + override = TEST_INJECTOR.get(IOverrideTest.class); + Assert.assertEquals("Override returned incorrect override type.", override.getPriority(), OverrideTestPrimary.PRIORITY); + Assert.assertEquals("Incorrect override object returned.", override.getValue(), OverrideTestPrimary.VALUE); + + + // in-line get + // (make sure the returned type is correct and compiles, the actual value doesn't matter) + TEST_INJECTOR.get(IOverrideTest.class).getValue(); + + } -// @Test -// public void testBackupWorldGeneratorInjection() -// { -// WorldGeneratorInjector TEST_INJECTOR = new WorldGeneratorInjector(WorldGeneratorTestAssembly.getPackagePath(2)); -// WorldGeneratorInjector CORE_INJECTOR = new WorldGeneratorInjector(); -// -// -// // pre-dependency setup -// Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get()); -// Assert.assertNull("Nothing should have been bound.", CORE_INJECTOR.get()); -// -// -// // variables to use later -// IDhApiWorldGenerator generator; -// WorldGeneratorTestCore coreGenerator = new WorldGeneratorTestCore(); -// WorldGeneratorTestSecondary secondaryGenerator = new WorldGeneratorTestSecondary(); -// WorldGeneratorTestPrimary primaryGenerator = new WorldGeneratorTestPrimary(); -// -// -// // core generator binding -// try { TEST_INJECTOR.bind(coreGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } -// -// try -// { -// CORE_INJECTOR.bind(coreGenerator); -// Assert.fail("Core generator should not be bindable for core package injector."); -// } -// catch (IllegalArgumentException e) { /* this exception should be thrown */ } -// -// -// // core override -// Assert.assertNotNull("Test injector should've bound core override.", TEST_INJECTOR.get()); -// Assert.assertNull("Core injector should not have bound core override.", CORE_INJECTOR.get()); -// // standard get -// generator = TEST_INJECTOR.get(); -// Assert.assertEquals("Override returned incorrect override type.", generator.getOverrideType(), EDhApiOverridePriority.CORE); -// Assert.assertEquals("Incorrect generator returned.", generator.getThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); -// -// -// // secondary override -// TEST_INJECTOR.bind(secondaryGenerator); -// // priority gets -// generator = TEST_INJECTOR.get(); -// Assert.assertEquals("Override returned incorrect override type.", generator.getOverrideType(), EDhApiOverridePriority.SECONDARY); -// Assert.assertEquals("Incorrect override object returned.", generator.getThreadingMode(), WorldGeneratorTestSecondary.THREAD_MODE); -// -// -// // primary override -// TEST_INJECTOR.bind(primaryGenerator); -// // priority gets -// generator = TEST_INJECTOR.get(); -// Assert.assertEquals("Override returned incorrect override type.", generator.getOverrideType(), EDhApiOverridePriority.PRIMARY); -// Assert.assertEquals("Incorrect override object returned.", generator.getThreadingMode(), WorldGeneratorTestPrimary.THREAD_MODE); -// -// -// -// // in-line get -// // (make sure the returned type is correct and compiles, the actual value doesn't matter) -// TEST_INJECTOR.get().getThreadingMode(); -// -// } -// -// @Test -// public void testSpecificLevelWorldGeneratorInjection() -// { -// WorldGeneratorInjector TEST_INJECTOR = new WorldGeneratorInjector(WorldGeneratorTestAssembly.getPackagePath(2)); -// -// -// // pre-dependency setup -// Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get()); -// -// -// // variables to use later -// IDhApiWorldGenerator generator; -// WorldGeneratorTestCore backupGenerator = new WorldGeneratorTestCore(); -// WorldGeneratorTestPrimary levelGenerator = new WorldGeneratorTestPrimary(); -// -// IDhApiLevelWrapper boundLevel = new LevelWrapperTest(); -// IDhApiLevelWrapper unboundLevel = new LevelWrapperTest(); -// -// -// -// // backup generator binding -// try { TEST_INJECTOR.bind(backupGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } -// -// -// // get backup generator -// generator = TEST_INJECTOR.get(); -// Assert.assertNotNull("Backup generator not bound.", generator); -// Assert.assertEquals("Incorrect backup generator bound.", generator.getOverrideType(), EDhApiOverridePriority.CORE); -// Assert.assertEquals("Incorrect backup generator bound.", generator.getThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); -// -// -// // bind level specific -// try { TEST_INJECTOR.bind(boundLevel, levelGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } -// -// -// // get bound level generator -// generator = TEST_INJECTOR.get(boundLevel); -// Assert.assertNotNull("Level generator not bound.", generator); -// Assert.assertEquals("Incorrect level generator bound.", generator.getOverrideType(), EDhApiOverridePriority.PRIMARY); -// Assert.assertEquals("Incorrect level generator bound.", generator.getThreadingMode(), WorldGeneratorTestPrimary.THREAD_MODE); -// -// // get unbound level generator -// generator = TEST_INJECTOR.get(unboundLevel); -// Assert.assertNotNull("Backup level generator not bound.", generator); -// Assert.assertEquals("Incorrect level generator bound.", generator.getOverrideType(), EDhApiOverridePriority.CORE); -// Assert.assertEquals("Incorrect level generator bound.", generator.getThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); -// -// } + @Test + public void testBackupWorldGeneratorInjection() + { + WorldGeneratorInjector TEST_INJECTOR = new WorldGeneratorInjector(WorldGeneratorTestAssembly.getPackagePath(2)); + WorldGeneratorInjector CORE_INJECTOR = new WorldGeneratorInjector(); + + + // pre-dependency setup + Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get()); + Assert.assertNull("Nothing should have been bound.", CORE_INJECTOR.get()); + + + // variables to use later + ICoreDhApiWorldGenerator generator; + WorldGeneratorTestCore coreGenerator = new WorldGeneratorTestCore(); + WorldGeneratorTestSecondary secondaryGenerator = new WorldGeneratorTestSecondary(); + WorldGeneratorTestPrimary primaryGenerator = new WorldGeneratorTestPrimary(); + + + // core generator binding + try { TEST_INJECTOR.bind(coreGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } + + try + { + CORE_INJECTOR.bind(coreGenerator); + Assert.fail("Core generator should not be bindable for core package injector."); + } + catch (IllegalArgumentException e) { /* this exception should be thrown */ } + + + // core override + Assert.assertNotNull("Test injector should've bound core override.", TEST_INJECTOR.get()); + Assert.assertNull("Core injector should not have bound core override.", CORE_INJECTOR.get()); + // standard get + generator = TEST_INJECTOR.get(); + Assert.assertEquals("Override returned incorrect override type.", generator.getPriority(), OverrideInjector.CORE_PRIORITY); + Assert.assertEquals("Incorrect generator returned.", generator.getCoreThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); + + + // secondary override + TEST_INJECTOR.bind(secondaryGenerator); + // priority gets + generator = TEST_INJECTOR.get(); + Assert.assertEquals("Override returned incorrect override type.", generator.getPriority(), WorldGeneratorTestSecondary.PRIORITY); + Assert.assertEquals("Incorrect override object returned.", generator.getCoreThreadingMode(), WorldGeneratorTestSecondary.THREAD_MODE); + + + // primary override + TEST_INJECTOR.bind(primaryGenerator); + // priority gets + generator = TEST_INJECTOR.get(); + Assert.assertEquals("Override returned incorrect override type.", generator.getPriority(), WorldGeneratorTestPrimary.PRIORITY); + Assert.assertEquals("Incorrect override object returned.", generator.getCoreThreadingMode(), WorldGeneratorTestPrimary.THREAD_MODE); + + + + // in-line get + // (make sure the returned type is correct and compiles, the actual value doesn't matter) + EWorldGenThreadMode threadMode = TEST_INJECTOR.get().getCoreThreadingMode(); + + } + + @Test + public void testSpecificLevelWorldGeneratorInjection() + { + WorldGeneratorInjector TEST_INJECTOR = new WorldGeneratorInjector(WorldGeneratorTestAssembly.getPackagePath(2)); + + + // pre-dependency setup + Assert.assertNull("Nothing should have been bound.", TEST_INJECTOR.get()); + + + // variables to use later + ICoreDhApiWorldGenerator generator; + WorldGeneratorTestCore backupGenerator = new WorldGeneratorTestCore(); + WorldGeneratorTestPrimary levelGenerator = new WorldGeneratorTestPrimary(); + + ICoreDhApiLevelWrapper boundLevel = new LevelWrapperTest(); + ICoreDhApiLevelWrapper unboundLevel = new LevelWrapperTest(); + + + + // backup generator binding + try { TEST_INJECTOR.bind(backupGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } + + + // get backup generator + generator = TEST_INJECTOR.get(); + Assert.assertNotNull("Backup generator not bound.", generator); + Assert.assertEquals("Incorrect backup generator bound.", generator.getPriority(), OverrideInjector.CORE_PRIORITY); + Assert.assertEquals("Incorrect backup generator bound.", generator.getCoreThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); + + + // bind level specific + try { TEST_INJECTOR.bind(boundLevel, levelGenerator); } catch (IllegalArgumentException e) { Assert.fail("Core generator should be bindable for test package injector."); } + + + // get bound level generator + generator = TEST_INJECTOR.get(boundLevel); + Assert.assertNotNull("Level generator not bound.", generator); + Assert.assertEquals("Incorrect level generator bound.", generator.getPriority(), WorldGeneratorTestPrimary.PRIORITY); + Assert.assertEquals("Incorrect level generator bound.", generator.getCoreThreadingMode(), WorldGeneratorTestPrimary.THREAD_MODE); + + // get unbound level generator + generator = TEST_INJECTOR.get(unboundLevel); + Assert.assertNotNull("Backup level generator not bound.", generator); + Assert.assertEquals("Incorrect level generator bound.", generator.getPriority(), OverrideInjector.CORE_PRIORITY); + Assert.assertEquals("Incorrect level generator bound.", generator.getCoreThreadingMode(), WorldGeneratorTestCore.THREAD_MODE); + + } }