diff --git a/src/functionalTest/java/codechicken/multipart/test/DefaultContentFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/DefaultContentFunctionalTest.java index f59c8cc..a3c75f0 100644 --- a/src/functionalTest/java/codechicken/multipart/test/DefaultContentFunctionalTest.java +++ b/src/functionalTest/java/codechicken/multipart/test/DefaultContentFunctionalTest.java @@ -30,7 +30,12 @@ import codechicken.microblock.CornerMicroblock; import codechicken.microblock.CornerPlacement; import codechicken.microblock.CornerPlacement$; import codechicken.microblock.CornerPlacementGrid$; +import codechicken.microblock.EdgeMicroClass; import codechicken.microblock.EdgeMicroClass$; +import codechicken.microblock.EdgeMicroblock; +import codechicken.microblock.EdgePlacement; +import codechicken.microblock.EdgePlacement$; +import codechicken.microblock.EdgePlacementGrid$; import codechicken.microblock.FaceMicroClass; import codechicken.microblock.FaceMicroClass$; import codechicken.microblock.FaceMicroblock; @@ -43,11 +48,17 @@ import codechicken.microblock.MicroMaterialRegistry.IMicroMaterial; import codechicken.microblock.Microblock; import codechicken.microblock.MissingMicroMaterial; import codechicken.microblock.MissingMicroMaterial$; +import codechicken.microblock.PostMicroClass; import codechicken.microblock.PostMicroClass$; +import codechicken.microblock.PostMicroblock; +import codechicken.microblock.PostMicroblockClient; import codechicken.microblock.TopMicroMaterial; +import codechicken.multipart.JPartialOcclusion; import codechicken.multipart.MultiPartRegistry; import codechicken.multipart.MultiPartRegistry.IPartFactory2; +import codechicken.multipart.TEdgePart; import codechicken.multipart.TFacePart; +import codechicken.multipart.TNormalOcclusion; import scala.Tuple2; class DefaultContentFunctionalTest { @@ -167,6 +178,76 @@ class DefaultContentFunctionalTest { } } + @Test + void keepsEdgeAndPostFactoriesBoundsAndGeneratedParts() { + EdgeMicroClass$ edgeFactory = EdgeMicroClass$.MODULE$; + assertSame(edgeFactory, EdgePlacement$.MODULE$.microClass()); + assertSame(edgeFactory, EdgePlacement.microClass()); + assertSame(EdgePlacementGrid$.MODULE$, EdgePlacement$.MODULE$.placementGrid()); + assertSame(edgeFactory.aBounds(), EdgeMicroClass.aBounds()); + assertEquals("mcr_edge", edgeFactory.getName()); + assertEquals(EdgeMicroblock.class, edgeFactory.baseTrait()); + assertEquals(CommonMicroblockClient.class, edgeFactory.clientTrait()); + assertEquals(15, edgeFactory.itemSlot()); + assertEquals(0.5f, edgeFactory.getResistanceFactor()); + + Cuboid6[] edgeBounds = edgeFactory.aBounds(); + assertEquals(256, edgeBounds.length); + int populated = 0; + for (int edge = 0; edge < 12; edge++) { + for (int size = 1; size < 8; size++) { + assertCuboid(expectedEdgeBounds(edge, size / 8d), edgeBounds[size << 4 | edge]); + populated++; + } + } + assertEquals(populated, countPopulated(edgeBounds)); + + Microblock generatedEdge = edgeFactory.create(false, 0); + assertTrue(generatedEdge instanceof EdgeMicroblock); + assertTrue(generatedEdge instanceof TEdgePart); + for (int slot = 15; slot < 27; slot++) { + generatedEdge.setShape(3, slot); + EdgeMicroblock edge = (EdgeMicroblock) generatedEdge; + assertSame(edgeBounds[3 << 4 | slot - 15], edge.getBounds()); + assertEquals(slot - 15, generatedEdge.getShape()); + assertEquals(slot, edge.getSlot()); + } + + PostMicroClass$ postFactory = PostMicroClass$.MODULE$; + assertSame(postFactory.aBounds(), PostMicroClass.aBounds()); + assertEquals("mcr_post", postFactory.getName()); + assertEquals(PostMicroblock.class, postFactory.baseTrait()); + assertEquals(PostMicroblockClient.class, postFactory.clientTrait()); + assertEquals(0.5f, postFactory.getResistanceFactor()); + + Cuboid6[] postBounds = postFactory.aBounds(); + assertEquals(256, postBounds.length); + populated = 0; + for (int axis = 0; axis < 3; axis++) { + for (int size = 2; size < 8; size += 2) { + assertCuboid(expectedPostBounds(axis, size), postBounds[size << 4 | axis]); + populated++; + } + } + assertEquals(populated, countPopulated(postBounds)); + + Microblock generatedPost = postFactory.create(false, 0); + assertTrue(generatedPost instanceof PostMicroblock); + assertTrue(generatedPost instanceof JPartialOcclusion); + assertTrue(generatedPost instanceof TNormalOcclusion); + PostMicroblock post = (PostMicroblock) generatedPost; + for (int axis = 0; axis < 3; axis++) { + generatedPost.setShape(4, axis); + assertSame(postBounds[4 << 4 | axis], post.getBounds()); + assertEquals(edgeFactory.getClassId(), post.itemClassID()); + assertEquals(0.5f, post.getResistanceFactor()); + assertEquals(axis == 0, post.canPlaceTorchOnTop()); + assertEquals(1, post.getOcclusionBoxes().size()); + assertSame(post.getBounds(), post.getOcclusionBoxes().get(0)); + assertEquals(post.getOcclusionBoxes(), post.getPartialOcclusionBoxes()); + } + } + @Test void registersTheExactOrderedBuiltInMaterialsAndRemaps() throws Exception { List expectedNames = new ArrayList<>(); @@ -264,6 +345,48 @@ class DefaultContentFunctionalTest { return new Cuboid6(minX, minY, minZ, minX + size, minY + size, minZ + size); } + private static Cuboid6 expectedEdgeBounds(int edge, double size) { + switch (edge >> 2) { + case 0: + return axisBounds((edge & 2) == 0 ? 0 : 1 - size, 0, (edge & 1) == 0 ? 0 : 1 - size, size, 1, size); + case 1: + return axisBounds((edge & 1) == 0 ? 0 : 1 - size, (edge & 2) == 0 ? 0 : 1 - size, 0, size, size, 1); + case 2: + return axisBounds(0, (edge & 1) == 0 ? 0 : 1 - size, (edge & 2) == 0 ? 0 : 1 - size, 1, size, size); + default: + throw new AssertionError(edge); + } + } + + private static Cuboid6 expectedPostBounds(int axis, int size) { + double min = 0.5 - size / 16d; + double width = size / 8d; + switch (axis) { + case 0: + return axisBounds(min, 0, min, width, 1, width); + case 1: + return axisBounds(min, min, 0, width, width, 1); + case 2: + return axisBounds(0, min, min, 1, width, width); + default: + throw new AssertionError(axis); + } + } + + private static Cuboid6 axisBounds(double minX, double minY, double minZ, double sizeX, double sizeY, double sizeZ) { + return new Cuboid6(minX, minY, minZ, minX + sizeX, minY + sizeY, minZ + sizeZ); + } + + private static int countPopulated(Cuboid6[] bounds) { + int populated = 0; + for (Cuboid6 bound : bounds) { + if (bound != null) { + populated++; + } + } + return populated; + } + private static void assertCuboid(Cuboid6 expected, Cuboid6 actual) { assertEquals(expected.min.x, actual.min.x, 1e-12); assertEquals(expected.min.y, actual.min.y, 1e-12); diff --git a/src/functionalTest/java/codechicken/multipart/test/MicroblockPlacementFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/MicroblockPlacementFunctionalTest.java index 7cc3ea5..d7f2c64 100644 --- a/src/functionalTest/java/codechicken/multipart/test/MicroblockPlacementFunctionalTest.java +++ b/src/functionalTest/java/codechicken/multipart/test/MicroblockPlacementFunctionalTest.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -24,6 +25,7 @@ import codechicken.lib.raytracer.ExtendedMOP; import codechicken.lib.vec.BlockCoord; import codechicken.microblock.AdditionPlacement; import codechicken.microblock.CommonMicroblock; +import codechicken.microblock.EdgePlacement$; import codechicken.microblock.EdgePlacementGrid$; import codechicken.microblock.ExecutablePlacement; import codechicken.microblock.ExpandingPlacement; @@ -36,6 +38,8 @@ import codechicken.microblock.MicroblockPlacement; import codechicken.microblock.MicroblockPlacement$; import codechicken.microblock.PlacementGrid; import codechicken.microblock.PlacementProperties; +import codechicken.microblock.PostMicroClass$; +import codechicken.microblock.PostMicroblock; import codechicken.multipart.ControlKeyModifer; import codechicken.multipart.TileMultipart; import scala.Tuple2; @@ -46,6 +50,8 @@ class MicroblockPlacementFunctionalTest { private static final BlockCoord INTERNAL_POS = new BlockCoord(164, 200, 160); private static final BlockCoord EXPAND_POS = new BlockCoord(168, 200, 160); private static final BlockCoord CUSTOM_POS = new BlockCoord(172, 200, 160); + private static final BlockCoord POST_POS = new BlockCoord(176, 200, 160); + private static final BlockCoord POST_EXPAND_POS = new BlockCoord(180, 200, 160); private WorldServer world; private EntityPlayer player; @@ -197,6 +203,55 @@ class MicroblockPlacementFunctionalTest { assertSame(marker, result); } + @Test + void edgeCustomPlacementCreatesOnlyEvenPostsAtTheGridCentre() { + world.setBlock(POST_POS.x, POST_POS.y, POST_POS.z, Blocks.stone); + MovingObjectPosition centreHit = hit(POST_POS, 1.0); + + MicroblockPlacement odd = new MicroblockPlacement(player, centreHit, 1, material, true, EdgePlacement$.MODULE$); + assertEquals(-1, odd.slot()); + assertNull(odd.apply()); + + MicroblockPlacement even = new MicroblockPlacement( + player, + centreHit, + 2, + material, + true, + EdgePlacement$.MODULE$); + AdditionPlacement placement = assertInstanceOf(AdditionPlacement.class, even.apply()); + assertEquals(POST_POS.copy().offset(1), placement.pos()); + assertInstanceOf(PostMicroblock.class, placement.part()); + assertSame(PostMicroClass$.MODULE$, placement.part().microClass()); + assertEquals(2, placement.part().getSize()); + assertEquals(0, placement.part().getShape()); + } + + @Test + void edgeCustomPlacementExpandsAMatchingPostInPlace() { + Microblock original = PostMicroClass$.MODULE$.create(false, material); + original.setShape(2, 0); + TileMultipart tile = TileMultipart.addPart(world, POST_EXPAND_POS, original); + + MicroblockPlacement decision = new MicroblockPlacement( + player, + indexedHit(POST_EXPAND_POS, 0.25, 0), + 2, + material, + true, + EdgePlacement$.MODULE$); + ExpandingPlacement placement = assertInstanceOf(ExpandingPlacement.class, decision.apply()); + assertTrue(decision.internal()); + assertTrue(decision.doExpand()); + assertEquals(4, placement.part().getSize()); + assertEquals(0, placement.part().getShape()); + + placement.place(world, player, new ItemStack(net.minecraft.init.Items.stick)); + assertSame(original, tile.jPartList().get(0)); + assertEquals(4, original.getSize()); + assertEquals(0, original.getShape()); + } + private Microblock face(int size, int slot) { Microblock part = FaceMicroClass$.MODULE$.create(false, material); part.setShape(size, slot); @@ -232,6 +287,9 @@ class MicroblockPlacementFunctionalTest { clear(INTERNAL_POS); clear(EXPAND_POS); clear(CUSTOM_POS); + clear(POST_POS); + clear(POST_POS.copy().offset(1)); + clear(POST_EXPAND_POS); } private void clear(BlockCoord pos) { diff --git a/src/test/java/codechicken/microblock/EdgeMicroblockCharacterizationTest.java b/src/test/java/codechicken/microblock/EdgeMicroblockCharacterizationTest.java new file mode 100644 index 0000000..c34bdbb --- /dev/null +++ b/src/test/java/codechicken/microblock/EdgeMicroblockCharacterizationTest.java @@ -0,0 +1,255 @@ +package codechicken.microblock; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.Arrays; +import java.util.Set; +import java.util.TreeSet; + +import org.junit.jupiter.api.Test; +import org.objectweb.asm.Type; + +import codechicken.lib.vec.Cuboid6; +import codechicken.multipart.JPartialOcclusion; +import codechicken.multipart.PartMap; +import codechicken.multipart.TEdgePart; +import codechicken.multipart.TNormalOcclusion; + +class EdgeMicroblockCharacterizationTest { + + private static final Set PLACEMENT_FACADE_METHODS = signatures( + "customPlacement(Lcodechicken/microblock/MicroblockPlacement;)Lcodechicken/microblock/ExecutablePlacement;", + "expand(II)Z", + "microClass()Lcodechicken/microblock/EdgeMicroClass$;", + "opposite(II)I", + "placementGrid()Lcodechicken/microblock/EdgePlacementGrid$;", + "sneakOpposite(II)Z"); + private static final Set PLACEMENT_COMPANION_METHODS = signatures( + "customPlacement(Lcodechicken/microblock/MicroblockPlacement;)Lcodechicken/microblock/ExecutablePlacement;", + "microClass()Lcodechicken/microblock/EdgeMicroClass$;", + "microClass()Lcodechicken/microblock/MicroblockClass;", + "opposite(II)I", + "placementGrid()Lcodechicken/microblock/EdgePlacementGrid$;", + "placementGrid()Lcodechicken/microblock/PlacementGrid;"); + private static final Set EDGE_CLASS_FACADE_METHODS = signatures( + "aBounds()[Lcodechicken/lib/vec/Cuboid6;", + "aBounds_$eq([Lcodechicken/lib/vec/Cuboid6;)V", + "baseTrait()Ljava/lang/Class;", + "baseTraitId()I", + "clientTrait()Ljava/lang/Class;", + "clientTraitId()I", + "create(ZI)Lcodechicken/microblock/Microblock;", + "createPart(Ljava/lang/String;Lcodechicken/lib/data/MCDataInput;)Lcodechicken/microblock/Microblock;", + "createPart(Ljava/lang/String;Lnet/minecraft/nbt/NBTTagCompound;)Lcodechicken/microblock/Microblock;", + "getClassId()I", + "getName()Ljava/lang/String;", + "getResistanceFactor()F", + "itemSlot()I", + "placementProperties()Lcodechicken/microblock/EdgePlacement$;", + "register()V", + "register(I)V"); + private static final Set EDGE_CLASS_COMPANION_METHODS = signatures( + "aBounds()[Lcodechicken/lib/vec/Cuboid6;", + "aBounds_$eq([Lcodechicken/lib/vec/Cuboid6;)V", + "baseTrait()Ljava/lang/Class;", + "clientTrait()Ljava/lang/Class;", + "getName()Ljava/lang/String;", + "getResistanceFactor()F", + "itemSlot()I", + "placementProperties()Lcodechicken/microblock/EdgePlacement$;", + "placementProperties()Lcodechicken/microblock/PlacementProperties;"); + private static final Set POST_CLASS_FACADE_METHODS = signatures( + "aBounds()[Lcodechicken/lib/vec/Cuboid6;", + "aBounds_$eq([Lcodechicken/lib/vec/Cuboid6;)V", + "baseTrait()Ljava/lang/Class;", + "baseTraitId()I", + "clientTrait()Ljava/lang/Class;", + "clientTraitId()I", + "create(ZI)Lcodechicken/microblock/Microblock;", + "createPart(Ljava/lang/String;Lcodechicken/lib/data/MCDataInput;)Lcodechicken/microblock/Microblock;", + "createPart(Ljava/lang/String;Lnet/minecraft/nbt/NBTTagCompound;)Lcodechicken/microblock/Microblock;", + "getName()Ljava/lang/String;", + "getResistanceFactor()F", + "register()V"); + private static final Set POST_CLASS_COMPANION_METHODS = signatures( + "aBounds()[Lcodechicken/lib/vec/Cuboid6;", + "aBounds_$eq([Lcodechicken/lib/vec/Cuboid6;)V", + "baseTrait()Ljava/lang/Class;", + "clientTrait()Ljava/lang/Class;", + "getName()Ljava/lang/String;", + "getResistanceFactor()F"); + + @Test + void keepsAllFacadesCompanionsAndGeneratedTraitSurfaces() throws Exception { + assertFacade(EdgePlacement.class, PLACEMENT_FACADE_METHODS); + assertCompanion(EdgePlacement$.class, PlacementProperties.class, PLACEMENT_COMPANION_METHODS, false); + + assertFacade(EdgeMicroClass.class, EDGE_CLASS_FACADE_METHODS); + assertCompanion(EdgeMicroClass$.class, CommonMicroClass.class, EDGE_CLASS_COMPANION_METHODS, true); + + assertTrait( + EdgeMicroblock.class, + new Class[] { CommonMicroblock.class, TEdgePart.class }, + signatures( + "getBounds()Lcodechicken/lib/vec/Cuboid6;", + "getSlot()I", + "microClass()Lcodechicken/microblock/EdgeMicroClass$;", + "setShape(II)V")); + assertHelper( + "codechicken.microblock.EdgeMicroblock$class", + signatures( + "$init$(Lcodechicken/microblock/EdgeMicroblock;)V", + "getBounds(Lcodechicken/microblock/EdgeMicroblock;)Lcodechicken/lib/vec/Cuboid6;", + "getSlot(Lcodechicken/microblock/EdgeMicroblock;)I", + "microClass(Lcodechicken/microblock/EdgeMicroblock;)Lcodechicken/microblock/EdgeMicroClass$;", + "setShape(Lcodechicken/microblock/EdgeMicroblock;II)V")); + + assertFacade(PostMicroClass.class, POST_CLASS_FACADE_METHODS); + assertCompanion(PostMicroClass$.class, MicroblockClass.class, POST_CLASS_COMPANION_METHODS, true); + + assertTrait( + PostMicroblock.class, + new Class[] { JPartialOcclusion.class, TNormalOcclusion.class }, + signatures( + "canPlaceTorchOnTop()Z", + "codechicken$microblock$PostMicroblock$$super$occlusionTest(Lcodechicken/multipart/TMultiPart;)Z", + "getBounds()Lcodechicken/lib/vec/Cuboid6;", + "getOcclusionBoxes()Ljava/util/List;", + "getPartialOcclusionBoxes()Ljava/util/List;", + "getResistanceFactor()F", + "itemClassID()I", + "microClass()Lcodechicken/microblock/PostMicroClass$;", + "occlusionTest(Lcodechicken/multipart/TMultiPart;)Z")); + assertHelper( + "codechicken.microblock.PostMicroblock$class", + signatures( + "$init$(Lcodechicken/microblock/PostMicroblock;)V", + "canPlaceTorchOnTop(Lcodechicken/microblock/PostMicroblock;)Z", + "getBounds(Lcodechicken/microblock/PostMicroblock;)Lcodechicken/lib/vec/Cuboid6;", + "getOcclusionBoxes(Lcodechicken/microblock/PostMicroblock;)Ljava/util/List;", + "getPartialOcclusionBoxes(Lcodechicken/microblock/PostMicroblock;)Ljava/util/List;", + "getResistanceFactor(Lcodechicken/microblock/PostMicroblock;)F", + "itemClassID(Lcodechicken/microblock/PostMicroblock;)I", + "microClass(Lcodechicken/microblock/PostMicroblock;)Lcodechicken/microblock/PostMicroClass$;", + "occlusionTest(Lcodechicken/microblock/PostMicroblock;Lcodechicken/multipart/TMultiPart;)Z")); + + assertTrait( + PostMicroblockClient.class, + new Class[] { PostMicroblock.class, MicroblockClient.class }, + signatures( + "codechicken$microblock$PostMicroblockClient$$super$onAdded()V", + "codechicken$microblock$PostMicroblockClient$$super$read(Lcodechicken/lib/data/MCDataInput;)V", + "onAdded()V", + "onPartChanged(Lcodechicken/multipart/TMultiPart;)V", + "read(Lcodechicken/lib/data/MCDataInput;)V", + "recalcBounds()V", + "render(Lcodechicken/lib/vec/Vector3;I)V", + "renderBounds1()Lcodechicken/lib/vec/Cuboid6;", + "renderBounds1_$eq(Lcodechicken/lib/vec/Cuboid6;)V", + "renderBounds2()Lcodechicken/lib/vec/Cuboid6;", + "renderBounds2_$eq(Lcodechicken/lib/vec/Cuboid6;)V", + "shrinkFace(I)V", + "shrinkPost(Lcodechicken/microblock/PostMicroblock;)V", + "thisShrinks(Lcodechicken/microblock/PostMicroblock;)Z")); + assertHelper( + "codechicken.microblock.PostMicroblockClient$class", + signatures( + "$init$(Lcodechicken/microblock/PostMicroblockClient;)V", + "onAdded(Lcodechicken/microblock/PostMicroblockClient;)V", + "onPartChanged(Lcodechicken/microblock/PostMicroblockClient;Lcodechicken/multipart/TMultiPart;)V", + "read(Lcodechicken/microblock/PostMicroblockClient;Lcodechicken/lib/data/MCDataInput;)V", + "recalcBounds(Lcodechicken/microblock/PostMicroblockClient;)V", + "render(Lcodechicken/microblock/PostMicroblockClient;Lcodechicken/lib/vec/Vector3;I)V", + "shrinkFace(Lcodechicken/microblock/PostMicroblockClient;I)V", + "shrinkPost(Lcodechicken/microblock/PostMicroblockClient;Lcodechicken/microblock/PostMicroblock;)V", + "thisShrinks(Lcodechicken/microblock/PostMicroblockClient;Lcodechicken/microblock/PostMicroblock;)Z")); + } + + @Test + void keepsEdgePlacementRulesAndGridIdentity() { + EdgePlacement$ placement = EdgePlacement$.MODULE$; + assertSame(EdgePlacementGrid$.MODULE$, placement.placementGrid()); + assertSame(EdgePlacementGrid$.MODULE$, EdgePlacement.placementGrid()); + + for (int slot = -3; slot < 0; slot++) { + for (int side = 0; side < 6; side++) { + assertEquals(slot, placement.opposite(slot, side)); + assertEquals(slot, EdgePlacement.opposite(slot, side)); + } + } + for (int slot = 15; slot < 27; slot++) { + for (int side = 0; side < 6; side++) { + int edge = slot - 15; + int opposite = 15 + PartMap.packEdgeBits(edge, PartMap.unpackEdgeBits(edge) ^ (1 << (side >> 1))); + assertEquals(opposite, placement.opposite(slot, side)); + assertEquals(opposite, EdgePlacement.opposite(slot, side)); + assertTrue(placement.sneakOpposite(slot, side)); + assertTrue(EdgePlacement.sneakOpposite(slot, side)); + assertTrue(placement.expand(slot, side)); + assertTrue(EdgePlacement.expand(slot, side)); + } + } + } + + private static void assertFacade(Class type, Set methods) { + assertTrue(Modifier.isPublic(type.getModifiers())); + assertTrue(Modifier.isFinal(type.getModifiers())); + assertSame(Object.class, type.getSuperclass()); + assertEquals(0, type.getDeclaredFields().length); + assertEquals(methods, publicDeclaredMethods(type)); + } + + private static void assertCompanion(Class type, Class superclass, Set methods, boolean hasBounds) + throws Exception { + assertTrue(Modifier.isPublic(type.getModifiers())); + assertTrue(Modifier.isFinal(type.getModifiers())); + assertSame(superclass, type.getSuperclass()); + assertEquals(methods, publicDeclaredMethods(type)); + Field module = type.getField("MODULE$"); + assertSame(type, module.getType()); + assertTrue(Modifier.isStatic(module.getModifiers())); + assertTrue(Modifier.isFinal(module.getModifiers())); + if (hasBounds) { + Field bounds = type.getDeclaredField("aBounds"); + assertSame(Cuboid6[].class, bounds.getType()); + assertTrue(Modifier.isPrivate(bounds.getModifiers())); + assertFalse(Modifier.isFinal(bounds.getModifiers())); + } + assertEquals(hasBounds ? 2 : 1, type.getDeclaredFields().length); + } + + private static void assertTrait(Class type, Class[] interfaces, Set methods) { + assertTrue(type.isInterface()); + assertArrayEquals(interfaces, type.getInterfaces()); + assertEquals(methods, publicDeclaredMethods(type)); + } + + private static void assertHelper(String name, Set methods) throws Exception { + Class type = Class.forName(name, false, EdgeMicroblockCharacterizationTest.class.getClassLoader()); + assertTrue(Modifier.isPublic(type.getModifiers())); + assertTrue(Modifier.isAbstract(type.getModifiers())); + assertSame(Object.class, type.getSuperclass()); + assertEquals(methods, publicDeclaredMethods(type)); + } + + private static Set publicDeclaredMethods(Class type) { + Set methods = new TreeSet<>(); + for (Method method : type.getDeclaredMethods()) { + if (Modifier.isPublic(method.getModifiers())) { + methods.add(method.getName() + Type.getMethodDescriptor(method)); + } + } + return methods; + } + + private static Set signatures(String... signatures) { + return new TreeSet<>(Arrays.asList(signatures)); + } +}