diff options
Diffstat (limited to 'src/test/java')
5 files changed, 860 insertions, 0 deletions
diff --git a/src/test/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBaseTest.java b/src/test/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBaseTest.java new file mode 100644 index 0000000000..a6f874b956 --- /dev/null +++ b/src/test/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBaseTest.java @@ -0,0 +1,46 @@ +package gregtech.api.metatileentity.implementations; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.mockito.Answers; +import org.mockito.Mockito; + +/** + * Tests some functions of {@link GT_MetaTileEntity_MultiBlockBase}. + * <p> + * The classes and tests are non-public because JUnit5 + * <a href="https://junit.org/junit5/docs/snapshot/user-guide/#writing-tests-classes-and-methods">recommends</a> + * to omit the {@code public} modifier. + */ +@SuppressWarnings("NewClassNamingConvention") /* + * The name of the original class does not fit the convention, + * but refactoring that is a story for another time. + */ +class GT_MetaTileEntity_MultiBlockBaseTest { + + @ParameterizedTest + @CsvSource({ "0,0,false", "2,0,false", "1,0,true", "1,1,false", "0,1,true", "0,2,true", "0,3,false" }) + void checkExoticAndNormalEnergyHatches_parametrizedTest(int exoticEnergyHatchesCount, int normalEnergyHatchesCount, + boolean expectedResult) { + GT_MetaTileEntity_MultiBlockBase testedClassInstance = Mockito + .mock(GT_MetaTileEntity_MultiBlockBase.class, Answers.CALLS_REAL_METHODS); + + testedClassInstance.setEnergyHatches(fillList(GT_MetaTileEntity_Hatch_Energy.class, normalEnergyHatchesCount)); + testedClassInstance.setExoticEnergyHatches(fillList(GT_MetaTileEntity_Hatch.class, exoticEnergyHatchesCount)); + + assertEquals(expectedResult, testedClassInstance.checkExoticAndNormalEnergyHatches()); + } + + private <T> ArrayList<T> fillList(Class<T> classData, int returnedListSize) { + T objectToInsert = Mockito.mock(classData); + ArrayList<T> listToReturn = new ArrayList<>(); + for (int i = 0; i < returnedListSize; i++) { + listToReturn.add(objectToInsert); + } + return listToReturn; + } +} diff --git a/src/test/java/gregtech/common/items/CombTypeTest.java b/src/test/java/gregtech/common/items/CombTypeTest.java new file mode 100644 index 0000000000..d9ae1a46ca --- /dev/null +++ b/src/test/java/gregtech/common/items/CombTypeTest.java @@ -0,0 +1,42 @@ +package gregtech.common.items; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.HashSet; +import java.util.Set; + +import org.junit.jupiter.api.Test; + +class CombTypeTest { + + @Test + void noDuplicateID() { + Set<Integer> seen = new HashSet<>(); + for (CombType value : CombType.values()) { + assertTrue(seen.add(value.getId()), "Comb type must not have duplicate ID"); + } + } + + @Test + void noNegativeID() { + for (CombType value : CombType.values()) { + if (value == CombType._NULL) assertTrue(value.getId() <= 0, "Comb type ID must be negative for _NULL"); + else assertTrue(value.getId() >= 0, "Comb type ID must not be negative"); + } + } + + @Test + void invalidIDNotNull() { + assertEquals(CombType.valueOf(-2), CombType._NULL, "Invalid ID Lookup should result in _NULL"); + assertEquals(CombType.valueOf(Integer.MAX_VALUE), CombType._NULL, "Invalid ID Lookup should result in _NULL"); + } + + @Test + void validIDCorrectComb() { + for (CombType value : CombType.values()) { + if (value != CombType._NULL) + assertEquals(CombType.valueOf(value.getId()), value, "Valid ID Lookup should result in correct output"); + } + } +} diff --git a/src/test/java/gregtech/globalenergymap/IGlobalWirelessEnergy_UnitTest.java b/src/test/java/gregtech/globalenergymap/IGlobalWirelessEnergy_UnitTest.java new file mode 100644 index 0000000000..012055133b --- /dev/null +++ b/src/test/java/gregtech/globalenergymap/IGlobalWirelessEnergy_UnitTest.java @@ -0,0 +1,127 @@ +package gregtech.globalenergymap; + +import static gregtech.common.misc.GlobalVariableStorage.GlobalEnergy; +import static gregtech.common.misc.WirelessNetworkManager.addEUToGlobalEnergyMap; +import static gregtech.common.misc.WirelessNetworkManager.clearGlobalEnergyInformationMaps; +import static gregtech.common.misc.WirelessNetworkManager.getUserEU; +import static gregtech.common.misc.WirelessNetworkManager.strongCheckOrAddUser; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.math.BigInteger; +import java.util.UUID; + +import org.junit.jupiter.api.Test; + +import gregtech.common.misc.spaceprojects.SpaceProjectManager; + +class IGlobalWirelessEnergy_UnitTest { + + static final String message = "Comparison failed"; + + @Test + void IGlobalWirelessEnergy_AddingEU() { + + UUID test_id = UUID.randomUUID(); + + addEUToGlobalEnergyMap(test_id, new BigInteger("1")); + assertEquals(GlobalEnergy.get(test_id), new BigInteger("1"), message); + + addEUToGlobalEnergyMap(test_id, 1); + assertEquals(GlobalEnergy.get(test_id), new BigInteger("2"), message); + + addEUToGlobalEnergyMap(test_id, 1L); + assertEquals(GlobalEnergy.get(test_id), new BigInteger("3"), message); + + clearGlobalEnergyInformationMaps(); + } + + @Test + void IGlobalWirelessEnergy_NoNegativeEU() { + + UUID user_uuid = UUID.randomUUID(); + + strongCheckOrAddUser(user_uuid); + + assertFalse(addEUToGlobalEnergyMap(user_uuid, new BigInteger("-1"))); + assertEquals(getUserEU(user_uuid), BigInteger.ZERO, message); + + assertTrue(addEUToGlobalEnergyMap(user_uuid, new BigInteger("1"))); + assertEquals(getUserEU(user_uuid), BigInteger.ONE, message); + + assertFalse(addEUToGlobalEnergyMap(user_uuid, new BigInteger("-2"))); + assertEquals(getUserEU(user_uuid), BigInteger.ONE, message); + + assertTrue(addEUToGlobalEnergyMap(user_uuid, new BigInteger("1"))); + assertEquals(getUserEU(user_uuid), BigInteger.valueOf(2L), message); + + assertTrue(addEUToGlobalEnergyMap(user_uuid, new BigInteger("-2"))); + assertEquals(getUserEU(user_uuid), BigInteger.ZERO, message); + + clearGlobalEnergyInformationMaps(); + } + + @Test + void IGlobalWirelessEnergy_StrongCheckOrAddUser() { + UUID user_uuid = UUID.randomUUID(); + + strongCheckOrAddUser(user_uuid); + assertEquals(GlobalEnergy.get(user_uuid), BigInteger.ZERO, message); + + clearGlobalEnergyInformationMaps(); + } + + @Test + void IGlobalWirelessEnergy_TeamChange() { + + UUID user_uuid_0 = UUID.randomUUID(); + + UUID user_uuid_1 = UUID.randomUUID(); + + UUID user_uuid_2 = UUID.randomUUID(); + + strongCheckOrAddUser(user_uuid_0); + strongCheckOrAddUser(user_uuid_1); + strongCheckOrAddUser(user_uuid_2); + + assertEquals(getUserEU(user_uuid_0), BigInteger.ZERO, message); + assertEquals(getUserEU(user_uuid_1), BigInteger.ZERO, message); + assertEquals(getUserEU(user_uuid_2), BigInteger.ZERO, message); + + SpaceProjectManager.putInTeam(user_uuid_0, user_uuid_1); + SpaceProjectManager.putInTeam(user_uuid_2, user_uuid_1); + + assertEquals(SpaceProjectManager.getLeader(user_uuid_0), user_uuid_1, message); + assertEquals(SpaceProjectManager.getLeader(user_uuid_2), user_uuid_1, message); + + assertTrue(addEUToGlobalEnergyMap(user_uuid_0, BigInteger.ONE)); + assertTrue(addEUToGlobalEnergyMap(user_uuid_2, BigInteger.ONE)); + + assertEquals(getUserEU(user_uuid_0), BigInteger.valueOf(2L), message); + assertEquals(getUserEU(user_uuid_1), BigInteger.valueOf(2L), message); + assertEquals(getUserEU(user_uuid_2), BigInteger.valueOf(2L), message); + + assertTrue(addEUToGlobalEnergyMap(user_uuid_0, BigInteger.valueOf(-1L))); + + assertEquals(getUserEU(user_uuid_0), BigInteger.ONE, message); + assertEquals(getUserEU(user_uuid_1), BigInteger.ONE, message); + assertEquals(getUserEU(user_uuid_2), BigInteger.ONE, message); + + assertFalse(addEUToGlobalEnergyMap(user_uuid_0, BigInteger.valueOf(-2L))); + + assertEquals(getUserEU(user_uuid_0), BigInteger.ONE, message); + assertEquals(getUserEU(user_uuid_1), BigInteger.ONE, message); + assertEquals(getUserEU(user_uuid_2), BigInteger.ONE, message); + + SpaceProjectManager.putInTeam(user_uuid_0, user_uuid_0); + SpaceProjectManager.putInTeam(user_uuid_1, user_uuid_1); + SpaceProjectManager.putInTeam(user_uuid_2, user_uuid_2); + + assertEquals(getUserEU(user_uuid_0), BigInteger.ZERO, message); + assertEquals(getUserEU(user_uuid_1), BigInteger.ONE, message); + assertEquals(getUserEU(user_uuid_2), BigInteger.ZERO, message); + + clearGlobalEnergyInformationMaps(); + } +} diff --git a/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java new file mode 100644 index 0000000000..e1560b27cb --- /dev/null +++ b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java @@ -0,0 +1,598 @@ +package gregtech.overclock; + +import static gregtech.api.enums.GT_Values.V; +import static gregtech.api.enums.GT_Values.VP; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_OverclockCalculator; + +class GT_OverclockCalculator_UnitTest { + + private static final String messageDuration = "Duration Calculated Wrong"; + private static final String messageEUt = "EUt Calculated Wrong"; + + @Test + void fullPerfectOverclockEBF_Test() { + int heatDiscounts = (1800 * 4) / 900; + long correctConsumption = (long) Math.ceil(VP[5] * Math.pow(0.95, heatDiscounts)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[5]) + .setDuration(1024) + .setHeatOC(true) + .setHeatDiscount(true) + .setRecipeHeat(1800) + .setMachineHeat(1800 * 5) + .calculate(); + assertEquals(1024 >> 8, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void imperfectOverclockEBFWithOneHeatDiscount_Test() { + int heatDiscounts = 1; + long correctConsumption = (long) Math.ceil(VP[5] * Math.pow(0.95, heatDiscounts)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[5]) + .setDuration(1024) + .setHeatOC(true) + .setHeatDiscount(true) + .setRecipeHeat(1800) + .setMachineHeat(2700) + .calculate(); + assertEquals(1024 >> 4, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void imperfectOverclockEBFWithoutHeatDiscounts_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[5]) + .setDuration(1024) + .setHeatOC(true) + .setHeatDiscount(true) + .setRecipeHeat(1800) + .setMachineHeat(1800) + .calculate(); + assertEquals(1024 >> 4, calculator.getDuration(), messageDuration); + assertEquals(VP[5], calculator.getConsumption(), messageEUt); + } + + @Test + void perfectAndImperfectOverclockEBFWithTwoHeatDiscounts_Test() { + int heatDiscounts = 2; + long correctConsumption = (long) Math.ceil(VP[5] * Math.pow(0.95, heatDiscounts)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[5]) + .setDuration(1024) + .setHeatOC(true) + .setHeatDiscount(true) + .setRecipeHeat(1800) + .setMachineHeat(3600) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void generalImperfectOverclock_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(1024) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void generalPerfectOverclock_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(2048) + .enablePerfectOC() + .calculate(); + assertEquals(2048 >> 10, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void weirdHeatEBF_Test() { + int heatDiscounts = 3; + long correctConsumption = (long) Math.ceil(VP[6] * Math.pow(0.95, heatDiscounts)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(2048) + .setHeatOC(true) + .setHeatDiscount(true) + .setRecipeHeat(486) + .setMachineHeat(3900) + .calculate(); + assertEquals(2048 >> 6, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void doubleEnergyHatchOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setAmperage(4) + .setDuration(1024) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 6, calculator.getDuration(), messageDuration); + assertEquals(VP[7], calculator.getConsumption(), messageEUt); + } + + @Test + void doubleEnergyHatchOCForULV_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[0]) + .setEUt(V[6]) + .setAmperage(4) + .setDuration(1024) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 6, calculator.getDuration(), messageDuration); + assertEquals(VP[0] << 12, calculator.getConsumption(), messageEUt); + } + + @Test + void multiAmpHatchOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setAmperage(256) + .setDuration(1024) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 9, calculator.getDuration(), messageDuration); + assertEquals(VP[10], calculator.getConsumption(), messageEUt); + } + + @Test + void weirdAmpHatchOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setAmperage(320) + .setDuration(1024) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 9, calculator.getDuration(), messageDuration); + assertEquals(VP[10], calculator.getConsumption(), messageEUt); + } + + @Test + void parallelImperfectOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[8]) + .setAmperage(4) + .setDuration(1024) + .setParallel(16) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 6, calculator.getDuration(), messageDuration); + assertEquals(VP[9], calculator.getConsumption(), messageEUt); + } + + @Test + void parallelPerfectOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[8]) + .setAmperage(4) + .setDuration(4096) + .setParallel(16) + .setAmperageOC(true) + .enablePerfectOC() + .calculate(); + assertEquals(4096 >> 12, calculator.getDuration(), messageDuration); + assertEquals(VP[9], calculator.getConsumption(), messageEUt); + } + + @Test + void parallelMultiAmpOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setAmperage(320) + .setDuration(1024) + .setParallel(16) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 7, calculator.getDuration(), messageDuration); + assertEquals(VP[10], calculator.getConsumption(), messageEUt); + } + + @Test + void weirdParallelOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[8]) + .setDuration(1024) + .setParallel(8) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(VP[6] * 8, calculator.getConsumption(), messageEUt); + } + + @Test + void weirdParallelAndAmpsOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[8]) + .setAmperage(320) + .setDuration(1024) + .setParallel(8) + .setAmperageOC(true) + .calculate(); + assertEquals(1024 >> 9, calculator.getDuration(), messageDuration); + assertEquals(VP[6] * 8 * 256, calculator.getConsumption(), messageEUt); + } + + @Test + void weirdTimeOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(77) + .calculate(); + assertEquals(77 >> 5, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void stopsCorrectlyWhenOneTicking_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(1) + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + assertEquals(VP[1], calculator.getConsumption(), messageEUt); + } + + @Test + void imperfectOCWithEUtDiscount_Test() { + long correctConsumption = (long) Math.ceil(VP[1] * 0.9f) << 10; + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setEUtDiscount(0.9f) + .setDuration(1024) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void perfectOCWithEUtDiscount_Test() { + long correctConsumption = (long) Math.ceil(VP[1] * 0.9f) << 10; + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setEUtDiscount(0.9f) + .setDuration(1024) + .enablePerfectOC() + .calculate(); + assertEquals(1024 >> 10, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void imperfectOCWithSpeedBoost_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setSpeedBoost(0.9f) + .setDuration(1024) + .calculate(); + assertEquals((int) (1024 * 0.9f) >> 5, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void perfectOCWithSpeedBoost_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setSpeedBoost(0.9f) + .setDuration(2048) + .enablePerfectOC() + .calculate(); + assertEquals((int) (2048 * 0.9f) >> 10, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void perfectOC3TicksTo1Tick_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[4]) + .setEUt(V[5]) + .setDuration(3) + .enablePerfectOC() + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + assertEquals(VP[5], calculator.getConsumption(), messageEUt); + } + + @Test + void oneTickDiscountTurnsToOne_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(1) + .setOneTickDiscount(true) + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + assertEquals(1, calculator.getConsumption(), messageEUt); + } + + @Test + void oneTickDiscountImperfectOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setSpeedBoost(1.1f) + .setDuration(4) + .setOneTickDiscount(true) + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + + /* + * duration with speedboost = 5 + * log_2(5) ~ 2.3; + * round up to 3 to reach one tick duration + */ + int overclocksTillOneTick = 3; + int overclocksBeyondOneTick = 2; + + // 3 overclocks, each gives 4x consumption growth per tick (1920) + long targetEUt = VP[1] << 2 * overclocksTillOneTick; + // 2 remaining overclocks are beyond 1 tick, each provides 2x comsumption discount (480) + targetEUt >>= overclocksBeyondOneTick; + + assertEquals(targetEUt, calculator.getConsumption(), messageEUt); + } + + @Test + void oneTickDiscountPerfectOC_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setSpeedBoost(1.1f) + .setDuration(16) + .enablePerfectOC() + .setOneTickDiscount(true) + .calculate(); + + /* + * duration with speedboost = 18 + * log_4(18) ~ 2.08; + * round up to 3 to reach one tick duration + */ + int overclocksTillOneTick = 3; + int overclocksBeyondOneTick = 2; + + // 3 overclocks, each gives 4x consumption growth per tick (1920) + long targetEUt = VP[1] << 2 * overclocksTillOneTick; + // 2 remaining overclocks are beyond 1 tick, each provides 4x comsumption discount (120) + targetEUt >>= 2 * overclocksBeyondOneTick; + + assertEquals(targetEUt, calculator.getConsumption(), messageEUt); + assertEquals(1, calculator.getDuration(), messageDuration); + } + + @Test + void ulvRecipeWithDiscount_Test() { + long correctConsumption = (long) Math.ceil((VP[0] << 10) * 0.9f); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[0]) + .setEUt(V[6]) + .setEUtDiscount(0.9f) + .setDuration(1024) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeWithDiscountWithParallel_Test() { + long correctConsumption = (long) Math.ceil((VP[0] << 6) * 14 * 0.9f); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[0]) + .setEUt(V[5]) + .setEUtDiscount(0.9f) + .setParallel(14) + .setDuration(1024) + .calculate(); + assertEquals(1024 >> 3, calculator.getDuration(), messageDuration); + assertEquals(correctConsumption, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeStopsWhenOneTicked_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[0]) + .setEUt(V[6]) + .setDuration(1) + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + assertEquals(VP[0], calculator.getConsumption(), messageEUt); + } + + @Test + void testNotPowerOverflowing_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(16) + .setParallel(64) + .setAmperage(64) + .setAmperageOC(true) + .setEUt(V[5]) + .setDuration(30) + .calculate(); + assertEquals(1, calculator.getDuration(), messageDuration); + assertEquals(16 << 14, calculator.getConsumption(), messageEUt); + } + + @Test + void testCorrectEUtWhenOverclockingUnderOneTick_Test() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(24) + .setParallel(56) + .setAmperage(1) + .setAmperageOC(true) + .setSpeedBoost(1f / 6f) + .setEUt(V[14]) + .setDuration(56); + assertEquals((24 * 56) << 20, calculator.calculateEUtConsumptionUnderOneTick(56, 6144)); + } + + @Test + void testCorrectEUtWhenOverclockingUnderOneTickWithHeat_Test() { + double heatDiscount = Math.pow(0.95, (15500 - 2000) / 900); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(1920) + .setParallel(256) + .setAmperage(1) + .setAmperageOC(true) + .setHeatDiscount(true) + .setHeatOC(true) + .setRecipeHeat(2000) + .setMachineHeat(15500) + .setEUt(V[12] * 1_048_576) + .setDuration(250); + assertEquals( + Math.ceil((((long) 1920 * 256) << 28) * heatDiscount), + calculator + .calculateEUtConsumptionUnderOneTick(256, (int) (256 / calculator.calculateDurationUnderOneTick()))); + } + + @Test + void testNoOverclockCorrectWithUnderOneTickLogic_Test() { + GT_OverclockCalculator calculator = GT_OverclockCalculator.ofNoOverclock(2_693_264_510L, 100) + .setParallel(24 * 64); + assertEquals(100, calculator.calculateDurationUnderOneTick()); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOC() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(2) + .setEUt(V[3]) + .setParallel(16) + .setDuration(20) + .setAmperageOC(false) + .setAmperage(16) + .calculate(); + assertEquals(32 * 16, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion2() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(2) + .setEUt(V[3]) + .setParallel(64) + .setDuration(20) + .setAmperageOC(false) + .setAmperage(16) + .calculate(); + assertEquals((32 * 64), calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion3() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(2) + .setEUt(V[3]) + .setParallel(16) + .setDuration(20) + .setAmperageOC(false) + .setAmperage(64) + .calculate(); + assertEquals(32 * 16, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion4() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(8) + .setEUt(V[3]) + .setParallel(16) + .setDuration(20) + .setAmperageOC(false) + .setAmperage(16) + .calculate(); + assertEquals((8 << 4) * 16, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion5() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(8) + .setEUt(V[3]) + .setParallel(16) + .setDuration(20) + .setAmperageOC(false) + .calculate(); + assertEquals((8 << 2) * 16, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion6() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(7) + .setEUt(V[3]) + .setParallel(64) + .setDuration(160) + .setAmperage(64) + .setAmperageOC(false) + .calculate(); + assertEquals((7 << 4) * 64, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion7() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(7) + .setEUt(V[3]) + .setParallel(19) + .setDuration(160) + .setAmperage(19) + .setAmperageOC(false) + .calculate(); + assertEquals((7 << 4) * 19, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeDoesntOverclockExtraWithAmperageWithoutAmperageOCVersion8() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(7) + .setEUt(V[3]) + .setParallel(29) + .setDuration(160) + .setAmperage(25) + .setAmperageOC(false) + .calculate(); + assertEquals((7 << 4) * 29, calculator.getConsumption(), messageEUt); + } + + @Test + void ulvRecipeWorkCorrectlyWithCalculatingEutUnderOneTick() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(2) + .setEUt(TierEU.UV) + .setParallel(64) + .setDuration(300) + .setAmperage(64) + .setAmperageOC(false); + assertEquals(TierEU.LuV * 64, calculator.calculateEUtConsumptionUnderOneTick(64, 64), messageEUt); + } + + @Test + void overclockWithAbnormalEnergyIncrease_Test() { + long expectedEUt = (long) Math.floor(VP[1] * Math.pow(4.1, 5)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(1024) + .setEUtIncreasePerOC(4.1) + .calculate(); + assertEquals(1024 >> 5, calculator.getDuration(), messageDuration); + assertEquals(expectedEUt, calculator.getConsumption(), messageEUt); + } + + @Test + void overclockWithAbnormalDurationDecrease_Test() { + int expectedDuration = (int) Math.floor(1024 / Math.pow(2.1, 5)); + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]) + .setEUt(V[6]) + .setDuration(1024) + .setDurationDecreasePerOC(2.1) + .calculate(); + assertEquals(expectedDuration, calculator.getDuration(), messageDuration); + assertEquals(VP[6], calculator.getConsumption(), messageEUt); + } + + @Test + void slightlyOverOneAmpRecipeWorksWithSingleEnergyHatch() { + GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(614400) + .setEUt(TierEU.UV) + .setDuration(600) + .setAmperage(2) + .setAmperageOC(false) + .calculate(); + assertEquals(600, calculator.getDuration(), messageDuration); + assertEquals(614400, calculator.getConsumption(), messageEUt); + } +} diff --git a/src/test/java/net/glease/ggfab/util/OverclockHelperTest.java b/src/test/java/net/glease/ggfab/util/OverclockHelperTest.java new file mode 100644 index 0000000000..7badd41fbe --- /dev/null +++ b/src/test/java/net/glease/ggfab/util/OverclockHelperTest.java @@ -0,0 +1,47 @@ +package net.glease.ggfab.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import org.junit.jupiter.api.Test; + +class OverclockHelperTest { + + @Test + void normalOverclockImperfect() { + // fails recipe + assertNull(OverclockHelper.normalOverclock(10000, 10000, 1, false)); + // no overclock + assertEquals(new OverclockHelper.OverclockOutput(30, 64), OverclockHelper.normalOverclock(30, 64, 32, false)); + // imperfect overclock + assertEquals(new OverclockHelper.OverclockOutput(120, 32), OverclockHelper.normalOverclock(30, 64, 128, false)); + // lots of overclock + assertEquals( + new OverclockHelper.OverclockOutput(30720, 2), + OverclockHelper.normalOverclock(30, 64, 32768, false)); + // do not overclock beyond useful + assertEquals( + new OverclockHelper.OverclockOutput(122880, 1), + OverclockHelper.normalOverclock(30, 64, 524288, false)); + } + + @Test + void laserOverclock() { + // fails recipe + assertNull(OverclockHelper.laserOverclock(10000, 10000, 1, 5)); + // no overclock + assertEquals(new OverclockHelper.OverclockOutput(30, 64), OverclockHelper.laserOverclock(30, 64, 32, 0.5f)); + // 0.3 amp overclock. 0.25 amp would be not in current tier so no point in testing that + assertEquals(new OverclockHelper.OverclockOutput(10, 64), OverclockHelper.laserOverclock(10, 64, 32, 0.5f)); + // laser overclock + assertEquals( + new OverclockHelper.OverclockOutput(135, 32), + OverclockHelper.laserOverclock(30, 64, 32 * 16, 0.5f)); + // lots of overclock + assertEquals( + new OverclockHelper.OverclockOutput(22272, 4), + OverclockHelper.laserOverclock(30, 64, 32 * 1024, 0.5f)); + // do not overclock beyond useful + assertEquals(new OverclockHelper.OverclockOutput(135, 1), OverclockHelper.laserOverclock(30, 2, 32 * 16, 0.5f)); + } +} |