Skip to content

Commit bf3c7d6

Browse files
robotgryphonrobotgryphon
committed
Convert junit tests to gametest tests, for full code coverage results
1 parent 4e5956b commit bf3c7d6

File tree

8 files changed

+245
-94
lines changed

8 files changed

+245
-94
lines changed

‎build.gradle‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -250,9 +250,6 @@ dependencies {
250250
// The userdev artifact is a special name and will get all sorts of transformations applied to it.
251251
minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
252252

253-
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
254-
testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.4.2'
255-
256253
// JEI
257254
compileOnly fg.deobf("mezz.jei:jei-${jei_mc_version}:${jei_version}:api")
258255
runtimeOnly fg.deobf("mezz.jei:jei-${jei_mc_version}:${jei_version}")
@@ -361,9 +358,3 @@ publishing {
361358
}
362359
}
363360
}
364-
365-
test {
366-
useJUnitPlatform {
367-
excludeTags "minecraft"
368-
}
369-
}

‎src/main/java/dev/compactmods/machines/tunnel/graph/TunnelConnectionGraph.java‎

Lines changed: 37 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
package dev.compactmods.machines.tunnel.graph;
22

3-
import java.util.HashMap;
4-
import java.util.Map;
5-
import java.util.Optional;
3+
import java.util.*;
64
import java.util.stream.Collectors;
75
import com.google.common.graph.MutableValueGraph;
86
import com.google.common.graph.ValueGraphBuilder;
@@ -161,4 +159,40 @@ public TunnelTypeNode createOrRegisterTunnelType(TunnelDefinition definition) {
161159
tunnelTypes.put(id, newType);
162160
return newType;
163161
}
162+
163+
/**
164+
* Gets the number of registered nodes in the graph.
165+
*/
166+
public int size() {
167+
return graph.nodes().size();
168+
}
169+
170+
public Set<BlockPos> getTunnels(TunnelDefinition type) {
171+
var defNode = tunnelTypes.get(type.getRegistryName());
172+
if(defNode == null)
173+
return Collections.emptySet();
174+
175+
return graph.predecessors(defNode)
176+
.stream()
177+
.filter(n -> n instanceof TunnelNode)
178+
.map(TunnelNode.class::cast)
179+
.map(TunnelNode::position)
180+
.map(BlockPos::immutable)
181+
.collect(Collectors.toSet());
182+
}
183+
184+
public Optional<Direction> getTunnelSide(BlockPos pos) {
185+
if(!tunnels.containsKey(pos))
186+
return Optional.empty();
187+
188+
var node = tunnels.get(pos);
189+
return graph.successors(node).stream()
190+
.filter(outNode -> outNode instanceof MachineNode)
191+
.map(mn -> graph.edgeValue(node, mn))
192+
.filter(Optional::isPresent)
193+
.map(Optional::get)
194+
.map(TunnelMachineEdge.class::cast)
195+
.map(TunnelMachineEdge::side)
196+
.findFirst();
197+
}
164198
}

‎src/test/java/dev/compactmods/machines/test/GraphTests.java‎

Lines changed: 94 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -1,29 +1,32 @@
11
package dev.compactmods.machines.test;
22

33
import java.util.Collection;
4+
import java.util.Objects;
45
import java.util.Optional;
56
import com.google.common.graph.Graph;
67
import com.mojang.serialization.DataResult;
8+
import dev.compactmods.machines.CompactMachines;
79
import dev.compactmods.machines.data.codec.CodecExtensions;
810
import dev.compactmods.machines.data.graph.CompactMachineConnectionGraph;
911
import dev.compactmods.machines.data.graph.CompactMachineNode;
1012
import dev.compactmods.machines.data.graph.CompactMachineRoomNode;
1113
import dev.compactmods.machines.data.graph.IMachineGraphNode;
1214
import dev.compactmods.machines.util.MathUtil;
15+
import net.minecraft.gametest.framework.GameTest;
16+
import net.minecraft.gametest.framework.GameTestHelper;
1317
import net.minecraft.nbt.CompoundTag;
1418
import net.minecraft.nbt.ListTag;
1519
import net.minecraft.nbt.NbtOps;
1620
import net.minecraft.nbt.Tag;
1721
import net.minecraft.world.level.ChunkPos;
18-
import org.junit.jupiter.api.Assertions;
19-
import org.junit.jupiter.api.DisplayName;
20-
import org.junit.jupiter.api.Test;
22+
import net.minecraftforge.gametest.GameTestHolder;
23+
import net.minecraftforge.gametest.PrefixGameTestTemplate;
2124

22-
@DisplayName("Machine Graph Tests")
23-
@org.junit.jupiter.api.Tag("minecraft")
25+
@PrefixGameTestTemplate(false)
26+
@GameTestHolder(CompactMachines.MOD_ID)
2427
public class GraphTests {
2528

26-
private CompactMachineConnectionGraph generateGraphWithSingleRoom() {
29+
private static CompactMachineConnectionGraph generateGraphWithSingleRoom() {
2730
CompactMachineConnectionGraph g = new CompactMachineConnectionGraph();
2831

2932
g.addMachine(0);
@@ -33,7 +36,7 @@ private CompactMachineConnectionGraph generateGraphWithSingleRoom() {
3336
return g;
3437
}
3538

36-
private CompactMachineConnectionGraph generateGraphWithMultipleRooms(int numRooms) {
39+
private static CompactMachineConnectionGraph generateGraphWithMultipleRooms(int numRooms) {
3740
CompactMachineConnectionGraph g = new CompactMachineConnectionGraph();
3841

3942
for (int i = 0; i < numRooms; i++) {
@@ -46,69 +49,83 @@ private CompactMachineConnectionGraph generateGraphWithMultipleRooms(int numRoom
4649
return g;
4750
}
4851

49-
private void verifySingleRoomValid(CompactMachineConnectionGraph graph, int machine, ChunkPos room) {
52+
private static void verifySingleRoomValid(GameTestHelper test, CompactMachineConnectionGraph graph, int machine, ChunkPos room) {
5053
Optional<ChunkPos> connectedRoom = graph.getConnectedRoom(machine);
51-
Assertions.assertTrue(connectedRoom.isPresent());
54+
if (connectedRoom.isEmpty())
55+
test.fail("Connected room not found.");
5256

5357
connectedRoom.ifPresent(cRoom -> {
54-
Assertions.assertEquals(room, cRoom);
58+
if (!room.equals(cRoom))
59+
test.fail("Room not equal.");
5560
});
5661
}
5762

58-
@Test
59-
@DisplayName("Can Create Basic Graph")
60-
void basicGraph() {
63+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
64+
public static void basicGraph(final GameTestHelper test) {
6165

6266
CompactMachineConnectionGraph g = new CompactMachineConnectionGraph();
6367

64-
Assertions.assertEquals(0, g.getMachines().count());
68+
if (g.getMachines().findAny().isPresent())
69+
test.fail("Graph should have been empty after construction.");
6570

6671
// At construction, no machines or rooms are registered
6772
// The method itself should just return an empty collection in this scenario
68-
Assertions.assertDoesNotThrow(() -> g.getMachinesFor(new ChunkPos(0, 0)));
73+
try {
74+
g.getMachinesFor(new ChunkPos(0, 0));
75+
} catch (Exception e) {
76+
test.fail(e.getMessage());
77+
}
6978

7079
// Make sure that there's no linked machines here
7180
Collection<Integer> linkedMachines = g.getMachinesFor(new ChunkPos(0, 0));
72-
Assertions.assertNotNull(linkedMachines);
73-
Assertions.assertEquals(0, linkedMachines.size());
81+
if (linkedMachines == null)
82+
test.fail("getMachinesFor should return an empty collection, not null");
83+
84+
if (!linkedMachines.isEmpty())
85+
test.fail("Linked machine collection should be empty.");
7486

7587
// Make sure there's no linked rooms
7688
Optional<ChunkPos> connectedRoom = g.getConnectedRoom(0);
77-
Assertions.assertNotNull(connectedRoom);
78-
Assertions.assertFalse(connectedRoom.isPresent());
89+
Objects.requireNonNull(connectedRoom);
90+
if (connectedRoom.isPresent())
91+
test.fail("No room connections should be present.");
92+
93+
test.succeed();
7994
}
8095

81-
@Test
82-
@DisplayName("Create Single Linked Machine (1:1)")
83-
void canCreateGraphWithLinkedMachine() {
96+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
97+
public static void canCreateGraphWithLinkedMachine(final GameTestHelper test) {
8498
int machine = 0;
8599
ChunkPos room = new ChunkPos(0, 0);
86100

87101
CompactMachineConnectionGraph g = generateGraphWithSingleRoom();
88102

89-
verifySingleRoomValid(g, machine, room);
103+
verifySingleRoomValid(test, g, machine, room);
90104

91105
Collection<Integer> linkedMachines = g.getMachinesFor(room);
92-
Assertions.assertEquals(1, linkedMachines.size());
93-
Assertions.assertTrue(linkedMachines.contains(machine));
106+
if (1 != linkedMachines.size())
107+
test.fail("Expected exactly one linked machine; got " + linkedMachines.size());
108+
109+
if (!linkedMachines.contains(machine))
110+
test.fail("Expected machine 0 to be linked; did not exist in linked machine collection");
111+
112+
test.succeed();
94113
}
95114

96115

97-
@Test
98-
@DisplayName("Create Multiple Rooms (1:1)")
99-
void canCreateMultipleRoomsWithSingleLinkedMachine() {
116+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
117+
public static void canCreateMultipleRoomsWithSingleLinkedMachine(final GameTestHelper test) {
100118
CompactMachineConnectionGraph graph = generateGraphWithMultipleRooms(10);
101119

102120
for (int roomIndex = 0; roomIndex < 10; roomIndex++) {
103121
final ChunkPos EXPECTED_CHUNK = MathUtil.getChunkForRoomIndex(roomIndex);
104122

105-
verifySingleRoomValid(graph, roomIndex, EXPECTED_CHUNK);
123+
verifySingleRoomValid(test, graph, roomIndex, EXPECTED_CHUNK);
106124
}
107125
}
108126

109-
@Test
110-
@DisplayName("Create Multiple Linked Machines (M:1)")
111-
void canCreateRoomWithMultipleLinkedMachines() {
127+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
128+
public static void canCreateRoomWithMultipleLinkedMachines(final GameTestHelper test) {
112129
int MACHINE_1 = 0;
113130
int MACHINE_2 = 1;
114131
ChunkPos EXPECTED_ROOM = new ChunkPos(0, 0);
@@ -123,55 +140,73 @@ void canCreateRoomWithMultipleLinkedMachines() {
123140
g.connectMachineToRoom(0, roomChunk);
124141
g.connectMachineToRoom(1, roomChunk);
125142

126-
verifySingleRoomValid(g, 0, EXPECTED_ROOM);
127-
verifySingleRoomValid(g, 1, EXPECTED_ROOM);
143+
verifySingleRoomValid(test, g, 0, EXPECTED_ROOM);
144+
verifySingleRoomValid(test, g, 1, EXPECTED_ROOM);
128145

129146
Collection<Integer> linkedMachines = g.getMachinesFor(EXPECTED_ROOM);
130-
Assertions.assertEquals(2, linkedMachines.size());
131-
Assertions.assertTrue(linkedMachines.contains(MACHINE_1));
132-
Assertions.assertTrue(linkedMachines.contains(MACHINE_2));
147+
if (2 != linkedMachines.size())
148+
test.fail("Linked machine count was not correct");
149+
150+
if (!linkedMachines.contains(MACHINE_1))
151+
test.fail("1st machine not found in linked machine set");
152+
;
153+
if (!linkedMachines.contains(MACHINE_2))
154+
test.fail("2nd machine not found in linked machine set");
155+
156+
test.succeed();
133157
}
134158

135-
@Test
136-
@DisplayName("Correctly serializes to NBT")
137-
void canSerialize() {
159+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
160+
public static void canSerialize(final GameTestHelper test) {
138161
CompactMachineConnectionGraph graph = generateGraphWithSingleRoom();
139162

140163
DataResult<Tag> nbtResult = CompactMachineConnectionGraph.CODEC.encodeStart(NbtOps.INSTANCE, graph);
141164

142-
nbtResult.resultOrPartial(Assertions::fail)
165+
nbtResult.resultOrPartial(test::fail)
143166
.ifPresent(nbt -> {
144-
Assertions.assertTrue(nbt instanceof CompoundTag);
167+
if (!(nbt instanceof CompoundTag graphData)) {
168+
test.fail("Encoded graph not expected tag type");
169+
return;
170+
}
171+
172+
if(!graphData.isEmpty())
173+
test.fail("Encoded tag does not have any data.");
145174

146-
CompoundTag c = (CompoundTag) nbt;
147-
Assertions.assertFalse(c.isEmpty());
175+
if(!graphData.contains("connections"))
176+
test.fail("Connection info not found.");
148177

149-
Assertions.assertTrue(c.contains("connections"));
178+
ListTag connections = graphData.getList("connections", Tag.TAG_COMPOUND);
179+
if(1 != connections.size())
180+
test.fail("Expected one connection from a machine to a single room.");
150181

151-
ListTag connections = c.getList("connections", Tag.TAG_COMPOUND);
152-
Assertions.assertEquals(1, connections.size(), "Expected one connection from a machine to a single room.");
182+
CompoundTag room1 = connections.getCompound(0);
153183

154-
CompoundTag conn1 = connections.getCompound(0);
155-
Assertions.assertNotNull(conn1);
184+
if(!room1.contains("machine"))
185+
test.fail("Machine info in connection not found.");
156186

157-
Assertions.assertTrue(conn1.contains("machine"));
158-
Assertions.assertTrue(conn1.contains("connections"));
187+
if(!room1.contains("connections"))
188+
test.fail("Machine connection info not found.");
159189

160-
Tag machineChunk = conn1.get("machine");
190+
Tag machineChunk = room1.get("machine");
161191
DataResult<ChunkPos> chunkRes = CodecExtensions.CHUNKPOS.parse(NbtOps.INSTANCE, machineChunk);
162-
chunkRes.resultOrPartial(Assertions::fail)
192+
chunkRes.resultOrPartial(test::fail)
163193
.ifPresent(chunk -> {
164-
Assertions.assertEquals(new ChunkPos(0, 0), chunk);
194+
if(!new ChunkPos(0, 0).equals(chunk))
195+
test.fail("Room chunk location is not correct.");
165196
});
166197

167-
ListTag connList = conn1.getList("connections", Tag.TAG_COMPOUND);
168-
Assertions.assertNotNull(connList);
169-
Assertions.assertEquals(1, connList.size());
170-
Assertions.assertEquals(0, connList.getInt(0));
198+
ListTag roomMachineConnections = room1.getList("connections", Tag.TAG_COMPOUND);
199+
if(1 != roomMachineConnections.size())
200+
test.fail("Expected exactly 1 machine to be connected to the room.");
201+
202+
if(0 != roomMachineConnections.getInt(0))
203+
test.fail("Expected the connected machine ID to be 0.");
171204
});
205+
206+
test.succeed();
172207
}
173208

174-
@Test
209+
@GameTest(template = "empty_1x1", batch = TestBatches.MACHINE_GRAPH)
175210
void simpleNestedMachines() {
176211
/*
177212
Overworld - Contains Machine 0, linked to Room 0

‎src/test/java/dev/compactmods/machines/test/MathTests.java‎

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,22 @@
11
package dev.compactmods.machines.test;
22

33
import java.util.HashMap;
4+
import dev.compactmods.machines.CompactMachines;
45
import dev.compactmods.machines.util.MathUtil;
56
import net.minecraft.core.BlockPos;
67
import net.minecraft.core.Vec3i;
8+
import net.minecraft.gametest.framework.GameTest;
9+
import net.minecraft.gametest.framework.GameTestHelper;
710
import net.minecraft.world.level.ChunkPos;
8-
import org.junit.jupiter.api.Assertions;
9-
import org.junit.jupiter.api.DisplayName;
10-
import org.junit.jupiter.api.Test;
11+
import net.minecraftforge.gametest.GameTestHolder;
12+
import net.minecraftforge.gametest.PrefixGameTestTemplate;
1113

12-
@DisplayName("Math")
14+
@PrefixGameTestTemplate(false)
15+
@GameTestHolder(CompactMachines.MOD_ID)
1316
public class MathTests {
1417

15-
@Test
16-
@DisplayName("Position Generator Works Correctly")
17-
void positionGeneratorWorksCorrectly() {
18+
@GameTest(template = "empty_1x1", batch = TestBatches.MATH)
19+
public static void positionGeneratorWorksCorrectly(final GameTestHelper test) {
1820
// Our generation works in a counter-clockwise spiral, starting at 0,0
1921
/*
2022
* 6 5 4
@@ -40,7 +42,8 @@ void positionGeneratorWorksCorrectly() {
4042
ChunkPos calculatedChunk = new ChunkPos(finalPos);
4143

4244
String error = String.format("Generation did not match for %s.", id);
43-
Assertions.assertEquals(expectedChunk, calculatedChunk, error);
45+
if(!expectedChunk.equals(calculatedChunk))
46+
test.fail(error);
4447
});
4548
}
4649
}

‎src/test/java/dev/compactmods/machines/test/TestBatches.java‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
package dev.compactmods.machines.test;
2+
3+
public class TestBatches {
4+
5+
public static final String TUNNEL_DATA = "tunnel_data";
6+
public static final String MACHINE_GRAPH = "machine_graph_data";
7+
public static final String CODEC_TESTS = "codecs";
8+
public static final String MATH = "math";
9+
}

0 commit comments

Comments
 (0)