Fixed occassional crashes of Power Tests and continued TDD

tests/src/test/java/power/ItemLiquidGeneratorTests.java

@@ -1,37 +1,57 @@
 package power;
 
+import io.anuke.mindustry.content.Liquids;
 import io.anuke.mindustry.type.Item;
 import io.anuke.mindustry.type.Liquid;
 import io.anuke.mindustry.world.Tile;
+import io.anuke.mindustry.world.blocks.power.BurnerGenerator;
+import io.anuke.mindustry.world.blocks.power.ItemGenerator;
 import io.anuke.mindustry.world.blocks.power.ItemLiquidGenerator;
+import io.anuke.mindustry.world.blocks.power.PowerGenerator;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /** This class tests the abstract ItemLiquidGenerator class and maybe some of its dependencies. */
 public class ItemLiquidGeneratorTests extends PowerTestFixture{
 
-    private ItemLiquidGenerator sut; // system under test (https://en.wikipedia.org/wiki/System_under_test)
+    private ItemLiquidGenerator generator;
     private Tile tile;
+    private ItemGenerator.ItemGeneratorEntity entity;
+    private final float fakeLiquidPowerMultiplier = 2.0f;
+    private final float fakeMaxLiquidGenerate = 0.5f;
 
     @BeforeEach
-    public void createItemLiquidGenerator(){
-        sut = new ItemLiquidGenerator("fakegen"){
-            @Override
-            protected float getLiquidEfficiency(Liquid liquid){
-                return liquid.flammability;
-            }
+    public void createBurnerGenerator(){
+        // Use a burner generator instead of a custom ItemLiquidGenerator subclass since we would implement abstract methods the same way.
+        generator = new BurnerGenerator("fakegen"){{
+            powerProduction = 0.1f;
+            itemDuration = 60f;
+            liquidPowerMultiplier = fakeLiquidPowerMultiplier;
+            maxLiquidGenerate = fakeMaxLiquidGenerate;
+        }};
 
-            @Override
-            protected float getItemEfficiency(Item item){
-                return item.flammability;
-            }
-        };
-        tile = createFakeTile(0, 0, sut);
+        tile = createFakeTile(0, 0, generator);
+        entity = tile.entity();
     }
 
     @Test
-    void detectCrashes(){
-        sut.update(tile);
+    void testLiquidConsumption(){
+        final float providedUsage = 0.1f;
+        final float expectedEfficiency = providedUsage / fakeMaxLiquidGenerate * fakeLiquidPowerMultiplier * Liquids.oil.flammability;
+
+        entity.liquids.add(Liquids.oil, providedUsage);
+        entity.cons.update(tile.entity);
+        assumeTrue(entity.cons.valid());
+
+        // Perform an update on the generator once - This should use up all oil and produce a fraction of what's possible
+        generator.update(tile);
+
+        assertEquals(0.0f, entity.liquids.get(Liquids.oil));
+        assertEquals(expectedEfficiency, entity.productionEfficiency);
     }
 }

tests/src/test/java/power/PowerTestFixture.java

@@ -3,17 +3,25 @@ package power;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.core.ContentLoader;
+import io.anuke.mindustry.core.World;
+import io.anuke.mindustry.entities.TileEntity;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.PowerBlock;
 import io.anuke.mindustry.world.blocks.power.Battery;
 import io.anuke.mindustry.world.blocks.power.PowerGenerator;
+import io.anuke.mindustry.world.modules.ConsumeModule;
+import io.anuke.mindustry.world.modules.ItemModule;
+import io.anuke.mindustry.world.modules.LiquidModule;
 import io.anuke.mindustry.world.modules.PowerModule;
+import io.anuke.ucore.entities.Entities;
 import org.junit.jupiter.api.BeforeAll;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
+import static io.anuke.mindustry.Vars.world;
+
 /** This class provides objects commonly used by power related unit tests.
  *  For now, this is a helper with static methods, but this might change.
  * */
@@ -62,7 +70,7 @@ public class PowerTestFixture{
 
             // Using the Tile(int, int, byte, byte) constructor would require us to register any fake block or tile we create
             // Since this part shall not be part of the test and would require more work anyway, we manually set the block and floor
-            // and call the private changed() method through reflections.
+            // through reflections and then simulate part of what the changed() method does.
 
             Field field = Tile.class.getDeclaredField("wall");
             field.setAccessible(true);
@@ -72,10 +80,15 @@ public class PowerTestFixture{
             field.setAccessible(true);
             field.set(tile, Blocks.sand);
 
-            Method method = Tile.class.getDeclaredMethod("changed");
-            method.setAccessible(true);
-            method.invoke(tile);
-
+            // Simulate the "changed" method. Calling it through reflections would require half the game to be initialized.
+            tile.entity = block.newEntity().init(tile, false);
+            tile.entity.cons = new ConsumeModule();
+            if(block.hasItems) tile.entity.items = new ItemModule();
+            if(block.hasLiquids) tile.entity.liquids = new LiquidModule();
+            if(block.hasPower){
+                tile.entity.power = new PowerModule();
+                tile.entity.power.graph.add(tile);
+            }
             return tile;
         }catch(Exception ex){
             return null;