[ci skip] spotlessApply with the new settings

1 files changed, 53 insertions, 174 deletions

diff --git a/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
index cc641f96e5..827bc48908 100644
--- a/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
+++ b/src/test/java/gregtech/overclock/GT_OverclockCalculator_UnitTest.java
@@ -4,9 +4,10 @@ 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 gregtech.api.util.GT_OverclockCalculator;
 import org.junit.jupiter.api.Test;
 
+import gregtech.api.util.GT_OverclockCalculator;
+
 class GT_OverclockCalculator_UnitTest {
 
     private static final String messageDuration = "Duration Calculated Wrong";
@@ -16,14 +17,8 @@ class GT_OverclockCalculator_UnitTest {
     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)
-                .enableHeatOC()
-                .enableHeatDiscount()
-                .setRecipeHeat(1800)
-                .setMultiHeat(1800 * 5)
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[5])
+                .setDuration(1024).enableHeatOC().enableHeatDiscount().setRecipeHeat(1800).setMultiHeat(1800 * 5)
                 .calculate();
         assertEquals(1024 >> 8, calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
@@ -33,14 +28,8 @@ class GT_OverclockCalculator_UnitTest {
     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)
-                .enableHeatOC()
-                .enableHeatDiscount()
-                .setRecipeHeat(1800)
-                .setMultiHeat(2700)
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[5])
+                .setDuration(1024).enableHeatOC().enableHeatDiscount().setRecipeHeat(1800).setMultiHeat(2700)
                 .calculate();
         assertEquals(1024 >> 4, calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
@@ -48,14 +37,8 @@ class GT_OverclockCalculator_UnitTest {
 
     @Test
     void imperfectOverclockEBFWithoutHeatDiscounts_Test() {
-        GT_OverclockCalculator calculator = new GT_OverclockCalculator()
-                .setRecipeEUt(VP[1])
-                .setEUt(V[5])
-                .setDuration(1024)
-                .enableHeatOC()
-                .enableHeatDiscount()
-                .setRecipeHeat(1800)
-                .setMultiHeat(1800)
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[5])
+                .setDuration(1024).enableHeatOC().enableHeatDiscount().setRecipeHeat(1800).setMultiHeat(1800)
                 .calculate();
         assertEquals(1024 >> 4, calculator.getDuration(), messageDuration);
         assertEquals(VP[5], calculator.getConsumption(), messageEUt);
@@ -65,14 +48,8 @@ class GT_OverclockCalculator_UnitTest {
     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)
-                .enableHeatOC()
-                .enableHeatDiscount()
-                .setRecipeHeat(1800)
-                .setMultiHeat(3600)
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[5])
+                .setDuration(1024).enableHeatOC().enableHeatDiscount().setRecipeHeat(1800).setMultiHeat(3600)
                 .calculate();
         assertEquals(1024 >> 5, calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
@@ -80,23 +57,16 @@ class GT_OverclockCalculator_UnitTest {
 
     @Test
     void generalImperfectOverclock_Test() {
-        GT_OverclockCalculator calculator = new GT_OverclockCalculator()
-                .setRecipeEUt(VP[1])
-                .setEUt(V[6])
-                .setDuration(1024)
-                .calculate();
+        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();
+        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);
     }
@@ -105,14 +75,8 @@ class GT_OverclockCalculator_UnitTest {
     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)
-                .enableHeatOC()
-                .enableHeatDiscount()
-                .setRecipeHeat(486)
-                .setMultiHeat(3900)
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setDuration(2048).enableHeatOC().enableHeatDiscount().setRecipeHeat(486).setMultiHeat(3900)
                 .calculate();
         assertEquals(2048 >> 6, calculator.getDuration(), messageDuration);
         assertEquals(correctConsumption, calculator.getConsumption(), messageEUt);
@@ -120,122 +84,79 @@ class GT_OverclockCalculator_UnitTest {
 
     @Test
     void doubleEnergyHatchOC_Test() {
-        GT_OverclockCalculator calculator = new GT_OverclockCalculator()
-                .setRecipeEUt(VP[1])
-                .setEUt(V[6] + V[6])
-                .setAmperage(2)
-                .setDuration(1024)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6] + V[6])
+                .setAmperage(2).setDuration(1024).calculate();
         assertEquals(1024 >> 6, calculator.getDuration(), messageDuration);
         assertEquals(VP[7], calculator.getConsumption(), messageEUt);
     }
 
     @Test
     void multiAmpHatchOC_Test() {
-        GT_OverclockCalculator calculator = new GT_OverclockCalculator()
-                .setRecipeEUt(VP[1])
-                .setEUt(V[6])
-                .setAmperage(256)
-                .setDuration(1024)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setAmperage(256).setDuration(1024).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)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setAmperage(320).setDuration(1024).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)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[8]).setAmperage(4)
+                .setDuration(1024).setParallel(16).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)
-                .enablePerfectOC()
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[8]).setAmperage(4)
+                .setDuration(4096).setParallel(16).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)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setAmperage(320).setDuration(1024).setParallel(16).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();
+        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)
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[8])
+                .setAmperage(320).setDuration(1024).setParallel(8).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();
+        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)
+        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);
@@ -244,12 +165,8 @@ class GT_OverclockCalculator_UnitTest {
     @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();
+        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);
     }
@@ -257,77 +174,48 @@ class GT_OverclockCalculator_UnitTest {
     @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();
+        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();
+        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();
+        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 oneTickDiscountTurnsToOne_Test() {
-        GT_OverclockCalculator calculator = new GT_OverclockCalculator()
-                .setRecipeEUt(VP[1])
-                .setEUt(V[6])
-                .setDuration(1)
-                .enableOneTickDiscount()
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6]).setDuration(1)
+                .enableOneTickDiscount().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)
-                .enableOneTickDiscount()
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setSpeedBoost(1.1f).setDuration(4).enableOneTickDiscount().calculate();
         assertEquals(1, calculator.getDuration(), messageDuration);
         assertEquals(480 >> 3, 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()
-                .enableOneTickDiscount()
-                .calculate();
+        GT_OverclockCalculator calculator = new GT_OverclockCalculator().setRecipeEUt(VP[1]).setEUt(V[6])
+                .setSpeedBoost(1.1f).setDuration(16).enablePerfectOC().enableOneTickDiscount().calculate();
         assertEquals(1, calculator.getDuration(), messageDuration);
         assertEquals(480 >> 6, calculator.getConsumption(), messageEUt);
     }
@@ -335,12 +223,8 @@ class GT_OverclockCalculator_UnitTest {
     @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();
+        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);
     }
@@ -348,13 +232,8 @@ class GT_OverclockCalculator_UnitTest {
     @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();
+        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);
     }