From 5ba9d4e1c460a27c850a28f634dbf6a670f23a04 Mon Sep 17 00:00:00 2001 From: Jean Tessier Date: Thu, 9 Jan 2025 21:25:11 -0800 Subject: [PATCH] Migrate some unit tests that are using jMock to JUnit Jupiter --- .../TestBootstrapMethodWithOneArgument.java | 90 +++++------ .../classreader/impl/TestClass_info.java | 2 +- .../classreader/impl/TestClassfile.java | 2 +- ...TestClassfile_locateMethodDeclaration.java | 2 +- .../impl/TestFrameType_create.java | 121 ++++++--------- ...stInterfaceMethodRef_info_NameAndType.java | 143 +++++++++-------- .../impl/TestMethodParameter_accessFlags.java | 95 +++++------- .../impl/TestMethodRef_info_NameAndType.java | 144 +++++++++--------- .../classreader/impl/TestMethod_info.java | 2 +- .../impl/TestMethod_info_NameAndType.java | 133 ++++++++-------- .../impl/TestModuleExports_exportsFlags.java | 85 +++++------ .../impl/TestModuleOpens_opensFlags.java | 85 +++++------ .../TestModuleRequires_requiresFlags.java | 125 +++++++-------- .../TestModuleRequires_requiresVersion.java | 114 +++++++------- .../TestModule_attribute_moduleFlags.java | 114 +++++++------- .../TestModule_attribute_moduleVersion.java | 105 +++++++------ .../impl/TestStackMapFrameFactory_create.java | 129 +++++++--------- ...estVerificationTypeInfoFactory_create.java | 90 +++++------ .../impl/TestVerificationType_create.java | 90 +++++------ 19 files changed, 758 insertions(+), 913 deletions(-) diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestBootstrapMethodWithOneArgument.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestBootstrapMethodWithOneArgument.java index 476e9a54..beba76c8 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestBootstrapMethodWithOneArgument.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestBootstrapMethodWithOneArgument.java @@ -34,67 +34,52 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestBootstrapMethodWithOneArgument { - @Parameters(name="BootstrapMethod with {0} argument") - public static Object[][] data() { - return new Object[][] { - {"an integer", 123, 1, com.jeantessier.classreader.Integer_info.class}, - {"a float", 234, 2, com.jeantessier.classreader.Float_info.class}, - {"a long", 345, 3, com.jeantessier.classreader.Long_info.class}, - {"a double", 456, 4, com.jeantessier.classreader.Double_info.class}, - {"a Class", 567, 5, com.jeantessier.classreader.Class_info.class}, - {"a String", 678, 6, com.jeantessier.classreader.String_info.class}, - {"a MethodHandle", 789, 7, com.jeantessier.classreader.MethodHandle_info.class}, - {"a MethodType", 890, 8, com.jeantessier.classreader.MethodType_info.class}, - {"a Dynamic", 909, 9, com.jeantessier.classreader.Dynamic_info.class}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("an integer", 123, 1, com.jeantessier.classreader.Integer_info.class), + arguments("a float", 234, 2, com.jeantessier.classreader.Float_info.class), + arguments("a long", 345, 3, com.jeantessier.classreader.Long_info.class), + arguments("a double", 456, 4, com.jeantessier.classreader.Double_info.class), + arguments("a Class", 567, 5, com.jeantessier.classreader.Class_info.class), + arguments("a String", 678, 6, com.jeantessier.classreader.String_info.class), + arguments("a MethodHandle", 789, 7, com.jeantessier.classreader.MethodHandle_info.class), + arguments("a MethodType", 890, 8, com.jeantessier.classreader.MethodType_info.class), + arguments("a Dynamic", 909, 9, com.jeantessier.classreader.Dynamic_info.class) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int bootstrapMethodRef; - - @Parameter(2) - public int argumentIndex; - - @Parameter(3) - public Class argumentClass; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private ConstantPool mockConstantPool; - private DataInput mockIn; - private com.jeantessier.classreader.ConstantPoolEntry mockArgument; - - private BootstrapMethods_attribute mockBootstrapMethods; - - private BootstrapMethod sut; - - @Before - public void setUp() throws IOException { - mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); - mockArgument = context.mock(argumentClass); + @DisplayName("getArguments") + @ParameterizedTest(name="with {0} argument") + @MethodSource("dataProvider") + void testGetArguments(String variation, int bootstrapMethodRef, int argumentIndex, Class argumentClass) throws Exception { + // Given + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + com.jeantessier.classreader.ConstantPoolEntry mockArgument = context.mock(argumentClass); + // and var mockBootstrapMethods = context.mock(BootstrapMethods_attribute.class); var mockBootstrapMethod = context.mock(MethodHandle_info.class, "bootstrap method"); + // and context.checking(new Expectations() {{ allowing (mockBootstrapMethods).getConstantPool(); will(returnValue(mockConstantPool)); @@ -113,12 +98,11 @@ public void setUp() throws IOException { will(returnValue(mockArgument)); }}); - sut = new BootstrapMethod(mockBootstrapMethods, mockIn); - } + // When + var sut = new BootstrapMethod(mockBootstrapMethods, mockIn); - @Test - public void testGetArguments() { - assertEquals("num arguments", 1, sut.getArguments().size()); - assertSame("argument", mockArgument, sut.getArguments().stream().findFirst().orElseThrow()); + // Then + assertEquals(1, sut.getArguments().size(),"num arguments"); + assertSame(mockArgument, sut.getArguments().stream().findFirst().orElseThrow(), "argument"); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestClass_info.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestClass_info.java index 4d5747c2..8e73bc28 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestClass_info.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestClass_info.java @@ -50,7 +50,7 @@ public class TestClass_info { private static final String FULL_CLASS_NAME = PACKAGE_NAME + "." + SIMPLE_CLASS_NAME; @RegisterExtension - public JUnit5Mockery context = new JUnit5Mockery() {{ + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile.java index 03ea8179..af4327a1 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile.java @@ -51,7 +51,7 @@ public class TestClassfile { private static final String TEST_METHOD_SIGNATURE = TEST_CLASS_NAME + ".foo()"; @RegisterExtension - public JUnit5Mockery context = new JUnit5Mockery() {{ + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile_locateMethodDeclaration.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile_locateMethodDeclaration.java index e61bbd26..32c9475f 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile_locateMethodDeclaration.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestClassfile_locateMethodDeclaration.java @@ -46,7 +46,7 @@ public class TestClassfile_locateMethodDeclaration { @RegisterExtension - public JUnit5Mockery context = new JUnit5Mockery() {{ + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestFrameType_create.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestFrameType_create.java index 48f28a01..7dc9150e 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestFrameType_create.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestFrameType_create.java @@ -34,81 +34,55 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; import java.util.*; +import java.util.stream.*; -import static org.junit.Assert.assertEquals; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestFrameType_create { - @Parameters(name="Stack Map Frame from tag {0}") - public static Object[][] data() { - return new Object[][] { - {"SAME (min)", 0, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class}, - {"SAME (max)", 63, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM (min)", 64, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM (max)", 127, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM_EXTENDED", 247, 456, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrameExtended.class}, - {"CHOP (min)", 248, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class}, - {"CHOP (min)", 250, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class}, - {"SAME_FRAME_EXTENDED", 251, 456, null, Collections.emptyList(), null, Collections.emptyList(), SameFrameExtended.class}, - {"APPEND (252 - 251 = 1)", 252, 456, null, List.of("TOP1"), null, Collections.emptyList(), AppendFrame.class}, - {"APPEND (253 - 251 = 2)", 253, 456, null, List.of("TOP1", "TOP2"), null, Collections.emptyList(), AppendFrame.class}, - {"APPEND (253 - 251 = 3)", 254, 456, null, List.of("TOP1", "TOP2", "TOP3"), null, Collections.emptyList(), AppendFrame.class}, - {"FULL_FRAME (empties)", 255, 456, 0, Collections.emptyList(), 0, Collections.emptyList(), FullFrame.class}, - {"FULL_FRAME (locals only)", 255, 456, 2, List.of("TOP1", "TOP2"), 0, Collections.emptyList(), FullFrame.class}, - {"FULL_FRAME (stack only)", 255, 456, 0, Collections.emptyList(), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class}, - {"FULL_FRAME (locals and stack)", 255, 456, 2, List.of("TOP1", "TOP2"), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("SAME (min)", 0, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class), + arguments("SAME (max)", 63, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM (min)", 64, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM (max)", 127, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM_EXTENDED", 247, 456, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrameExtended.class), + arguments("CHOP (min)", 248, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class), + arguments("CHOP (min)", 250, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class), + arguments("SAME_FRAME_EXTENDED", 251, 456, null, Collections.emptyList(), null, Collections.emptyList(), SameFrameExtended.class), + arguments("APPEND (252 - 251 = 1)", 252, 456, null, List.of("TOP1"), null, Collections.emptyList(), AppendFrame.class), + arguments("APPEND (253 - 251 = 2)", 253, 456, null, List.of("TOP1", "TOP2"), null, Collections.emptyList(), AppendFrame.class), + arguments("APPEND (253 - 251 = 3)", 254, 456, null, List.of("TOP1", "TOP2", "TOP3"), null, Collections.emptyList(), AppendFrame.class), + arguments("FULL_FRAME (empties)", 255, 456, 0, Collections.emptyList(), 0, Collections.emptyList(), FullFrame.class), + arguments("FULL_FRAME (locals only)", 255, 456, 2, List.of("TOP1", "TOP2"), 0, Collections.emptyList(), FullFrame.class), + arguments("FULL_FRAME (stack only)", 255, 456, 0, Collections.emptyList(), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class), + arguments("FULL_FRAME (locals and stack)", 255, 456, 2, List.of("TOP1", "TOP2"), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int frameType; - - @Parameter(2) - public Integer offsetDelta; - - @Parameter(3) - public Integer numberOfLocals; - - @Parameter(4) - public Collection locals; - - @Parameter(5) - public Integer numberOfStackItems; - - @Parameter(6) - public Collection stacks; - - @Parameter(7) - public Class expectedClass; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private VerificationTypeInfoFactory mockVerificationTypeInfoFactory; - private ConstantPool mockConstantPool; - private DataInput mockIn; - - private FrameType sut; - - @Before - public void setUp() throws IOException { - mockVerificationTypeInfoFactory = context.mock(VerificationTypeInfoFactory.class); - mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); + @DisplayName("create") + @ParameterizedTest(name="from tag {0}") + @MethodSource("dataProvider") + public void testCreate(String variation, int frameType, Integer offsetDelta, Integer numberOfLocals, Collection locals, Integer numberOfStackItems, Collection stacks, Class expectedClass) throws IOException { + // Given + var mockVerificationTypeInfoFactory = context.mock(VerificationTypeInfoFactory.class); + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + // and if (offsetDelta != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -116,6 +90,7 @@ public void setUp() throws IOException { }}); } + // and if (numberOfLocals != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -123,14 +98,16 @@ public void setUp() throws IOException { }}); } + // and for (String localName : locals) { - final VerificationTypeInfo mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, localName); + var mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, localName); context.checking(new Expectations() {{ oneOf (mockVerificationTypeInfoFactory).create(mockConstantPool, mockIn); will(returnValue(mockVerificationTypeInfo)); }}); } + // and if (numberOfStackItems != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -138,23 +115,23 @@ public void setUp() throws IOException { }}); } + // and for (String stackName : stacks) { - final VerificationTypeInfo mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, stackName); + var mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, stackName); context.checking(new Expectations() {{ oneOf (mockVerificationTypeInfoFactory).create(mockConstantPool, mockIn); will(returnValue(mockVerificationTypeInfo)); }}); } - // And - sut = FrameType.forTag(frameType); - } + // and + var sut = FrameType.forTag(frameType); - @Test - public void testCreate() throws IOException { + // When var actualStackMapFrame = sut.create(frameType, mockVerificationTypeInfoFactory, mockConstantPool, mockIn); - assertEquals(label, expectedClass, actualStackMapFrame.getClass()); - assertEquals(label, frameType, actualStackMapFrame.getFrameType()); + // Then + assertEquals(expectedClass, actualStackMapFrame.getClass(), variation); + assertEquals(frameType, actualStackMapFrame.getFrameType(), variation); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestInterfaceMethodRef_info_NameAndType.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestInterfaceMethodRef_info_NameAndType.java index 01f78f56..1489b06f 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestInterfaceMethodRef_info_NameAndType.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestInterfaceMethodRef_info_NameAndType.java @@ -34,58 +34,85 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestInterfaceMethodRef_info_NameAndType { private static final int CLASS_INDEX = 2; private static final String CLASS = "abc"; private static final int NAME_AND_TYPE_INDEX = 3; private static final String NAME = "def"; - @Parameters(name="MethodRef_info to {0} " + CLASS + ".{1} with type \"{2}\"") - public static Object[][] data() { - return new Object[][] { - {"void method", "(I)V", NAME + "(int)", "void", NAME + "(int): void", CLASS + "." + NAME + "(int): void"}, - {"regular method", "(Ljava/lang/String;)Ljava/lang/Object;", NAME + "(java.lang.String)", "java.lang.Object", NAME + "(java.lang.String): java.lang.Object", CLASS + "." + NAME + "(java.lang.String): java.lang.Object"}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("void method", "(I)V", NAME + "(int)", "void", NAME + "(int): void", CLASS + "." + NAME + "(int): void"), + arguments("regular method", "(Ljava/lang/String;)Ljava/lang/Object;", NAME + "(java.lang.String)", "java.lang.Object", NAME + "(java.lang.String): java.lang.Object", CLASS + "." + NAME + "(java.lang.String): java.lang.Object") + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public String type; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(2) - public String expectedSignature; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="class for {0} should be " + CLASS) + @MethodSource("dataProvider") + void testGetClass(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(CLASS, sut.getClassName()); + } - @Parameter(3) - public String expectedReturnType; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="signature for {0} should be {2}") + @MethodSource("dataProvider") + void testGetSignature(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(expectedSignature, sut.getSignature()); + } - @Parameter(4) - public String expectedUniqueName; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="full signature for {0} should be " + CLASS + ".{2}") + @MethodSource("dataProvider") + void testGetFullSignature(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); + } - @Parameter(5) - public String expectedFullUniqueName; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="return type for {0} should be {3}") + @MethodSource("dataProvider") + void testGetReturnType(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(expectedReturnType, sut.getReturnType()); + } - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="unique name for {0} should be {4}") + @MethodSource("dataProvider") + void testGetUniqueName(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(expectedUniqueName, sut.getUniqueName()); + } - private InterfaceMethodRef_info sut; + @DisplayName("InterfaceMethodRef_info") + @ParameterizedTest(name="full unique name for {0} should be {5}") + @MethodSource("dataProvider") + void testGetFullUniqueName(String label, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(type); + assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + } - @Before - public void setUp() throws IOException { + private InterfaceMethodRef_info createSut(String type) throws IOException { final ConstantPool mockConstantPool = context.mock(ConstantPool.class); final DataInput mockIn = context.mock(DataInput.class); @@ -96,57 +123,27 @@ public void setUp() throws IOException { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); - inSequence(dataReads); - will(returnValue(CLASS_INDEX)); + inSequence(dataReads); + will(returnValue(CLASS_INDEX)); oneOf (mockIn).readUnsignedShort(); - inSequence(dataReads); - will(returnValue(NAME_AND_TYPE_INDEX)); + inSequence(dataReads); + will(returnValue(NAME_AND_TYPE_INDEX)); allowing (mockConstantPool).get(CLASS_INDEX); - will(returnValue(mockClass_info)); + will(returnValue(mockClass_info)); allowing (mockClass_info).getName(); - will(returnValue(CLASS)); + will(returnValue(CLASS)); allowing (mockClass_info).getSimpleName(); - will(returnValue(CLASS)); + will(returnValue(CLASS)); allowing (mockConstantPool).get(NAME_AND_TYPE_INDEX); - will(returnValue(mockNameAndType_info)); + will(returnValue(mockNameAndType_info)); allowing (mockNameAndType_info).getName(); - will(returnValue(NAME)); + will(returnValue(NAME)); allowing (mockNameAndType_info).getType(); - will(returnValue(type)); + will(returnValue(type)); }}); - sut = new InterfaceMethodRef_info(mockConstantPool, mockIn); - } - - @Test - public void testGetClass() { - assertEquals(CLASS, sut.getClassName()); - } - - @Test - public void testGetSignature() { - assertEquals(expectedSignature, sut.getSignature()); - } - - @Test - public void testGetFullSignature() { - assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); - } - - @Test - public void testGetReturnType() { - assertEquals(expectedReturnType, sut.getReturnType()); - } - - @Test - public void testGetUniqueName() { - assertEquals(expectedUniqueName, sut.getUniqueName()); - } - - @Test - public void testGetFullUniqueName() { - assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + return new InterfaceMethodRef_info(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodParameter_accessFlags.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodParameter_accessFlags.java index bcdf9f1a..50149532 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodParameter_accessFlags.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodParameter_accessFlags.java @@ -34,56 +34,60 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.Stream; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestMethodParameter_accessFlags { - @Parameters(name="Method parameter with access flags {0}") - public static Object[][] data() { - return new Object[][] { - {"FINAL", 0x0010, true, false, false}, - {"SYNTHETIC", 0x1000, false, true, false}, - {"MANDATED", 0x8000, false, false, true}, - {"all of them", 0x9010, true, true, true}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("FINAL", 0x0010, true, false, false), + arguments("SYNTHETIC", 0x1000, false, true, false), + arguments("MANDATED", 0x8000, false, false, true), + arguments("all of them", 0x9010, true, true, true) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int accessFlags; - - @Parameter(2) - public boolean isFinal; - - @Parameter(3) - public boolean isSynthetic; - - @Parameter(4) - public boolean isMandated; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private DataInput mockIn; + @DisplayName("MethodParameter") + @ParameterizedTest(name="isFinal with access flags {0} should be {2}") + @MethodSource("dataProvider") + public void testIsFinal(String variation, int accessFlags, boolean isFinal, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(accessFlags); + assertEquals(isFinal, sut.isFinal()); + } - private MethodParameter sut; + @DisplayName("MethodParameter") + @ParameterizedTest(name="isSynthetic with access flags {0} should be {3}") + @MethodSource("dataProvider") + public void testIsSynthetic(String variation, int accessFlags, boolean isFinal, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(accessFlags); + assertEquals(isSynthetic, sut.isSynthetic()); + } - @Before - public void setUp() throws IOException { + @DisplayName("MethodParameter") + @ParameterizedTest(name="isMandated with access flags {0} should be {4}") + @MethodSource("dataProvider") + public void testIsMandated(String variation, int accessFlags, boolean isFinal, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(accessFlags); + assertEquals(isMandated, sut.isMandated()); + } + + private MethodParameter createSut(int accessFlags) throws IOException { var mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); + var mockIn = context.mock(DataInput.class); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -92,21 +96,6 @@ public void setUp() throws IOException { will(returnValue(accessFlags)); }}); - sut = new MethodParameter(mockConstantPool, mockIn); - } - - @Test - public void testIsFinal() { - assertEquals(label, isFinal, sut.isFinal()); - } - - @Test - public void testIsSynthetic() { - assertEquals(label, isSynthetic, sut.isSynthetic()); - } - - @Test - public void testIsMandated() { - assertEquals(label, isMandated, sut.isMandated()); + return new MethodParameter(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodRef_info_NameAndType.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodRef_info_NameAndType.java index 18461da4..57fa15a7 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodRef_info_NameAndType.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethodRef_info_NameAndType.java @@ -34,69 +34,93 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestMethodRef_info_NameAndType { private static final int CLASS_INDEX = 2; - private static final String CLASS = "abc"; + private static final String CLASS = "Abc"; private static final int NAME_AND_TYPE_INDEX = 3; - @Parameters(name="MethodRef_info to {0} " + CLASS + ".{1} with type \"{2}\"") - public static Object[][] data() { - return new Object[][] { - {"void method", "foo", "(I)V", "foo(int)", "void", "foo(int): void", CLASS + ".foo(int): void"}, - {"regular method", "foo", "(Ljava/lang/String;)Ljava/lang/Object;", "foo(java.lang.String)", "java.lang.Object", "foo(java.lang.String): java.lang.Object", CLASS + ".foo(java.lang.String): java.lang.Object"}, - {"constructor", "", "()V", CLASS + "()", "void", CLASS + "()", CLASS + "." + CLASS + "()"}, - {"static initializer", "", "()V", "static {}", "void", "static {}", CLASS + ".static {}"}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("void method", "foo", "(I)V", "foo(int)", "void", "foo(int): void", CLASS + ".foo(int): void"), + arguments("regular method", "foo", "(Ljava/lang/String;)Ljava/lang/Object;", "foo(java.lang.String)", "java.lang.Object", "foo(java.lang.String): java.lang.Object", CLASS + ".foo(java.lang.String): java.lang.Object"), + arguments("constructor", "", "()V", CLASS + "()", "void", CLASS + "()", CLASS + "." + CLASS + "()"), + arguments("static initializer", "", "()V", "static {}", "void", "static {}", CLASS + ".static {}") + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public String name; - - @Parameter(2) - public String type; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(3) - public String expectedSignature; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="class for {0} should be " + CLASS) + @MethodSource("dataProvider") + void testGetClass(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(CLASS, sut.getClassName()); + } - @Parameter(4) - public String expectedReturnType; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="signature for {0} should be {3}") + @MethodSource("dataProvider") + void testGetSignature(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(expectedSignature, sut.getSignature()); + } - @Parameter(5) - public String expectedUniqueName; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="full signature for {0} should be " + CLASS + ".{3}") + @MethodSource("dataProvider") + void testGetFullSignature(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); + } - @Parameter(6) - public String expectedFullUniqueName; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="return type for {0} should be {4}") + @MethodSource("dataProvider") + void testGetReturnType(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(expectedReturnType, sut.getReturnType()); + } - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="unique name for {0} should be {5}") + @MethodSource("dataProvider") + void testGetUniqueName(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(expectedUniqueName, sut.getUniqueName()); + } - private MethodRef_info sut; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="full unique name for {0} should be {6}") + @MethodSource("dataProvider") + void testGetFullUniqueName(String variation, String name, String type, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, type); + assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + } - @Before - public void setUp() throws IOException { - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); + private MethodRef_info createSut(String name, String type) throws IOException { + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); - final Class_info mockClass_info = context.mock(Class_info.class); - final NameAndType_info mockNameAndType_info = context.mock(NameAndType_info.class); + var mockClass_info = context.mock(Class_info.class); + var mockNameAndType_info = context.mock(NameAndType_info.class); - final Sequence dataReads = context.sequence("dataReads"); + var dataReads = context.sequence("dataReads"); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -121,36 +145,6 @@ public void setUp() throws IOException { will(returnValue(type)); }}); - sut = new MethodRef_info(mockConstantPool, mockIn); - } - - @Test - public void testGetClass() { - assertEquals(CLASS, sut.getClassName()); - } - - @Test - public void testGetSignature() { - assertEquals(expectedSignature, sut.getSignature()); - } - - @Test - public void testGetFullSignature() { - assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); - } - - @Test - public void testGetReturnType() { - assertEquals(expectedReturnType, sut.getReturnType()); - } - - @Test - public void testGetUniqueName() { - assertEquals(expectedUniqueName, sut.getUniqueName()); - } - - @Test - public void testGetFullUniqueName() { - assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + return new MethodRef_info(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info.java index 44f247a7..ef90a5dc 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info.java @@ -52,7 +52,7 @@ public class TestMethod_info { private static final int TEST_NB_ATTRIBUTES = 0; @RegisterExtension - public JUnit5Mockery context = new JUnit5Mockery() {{ + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info_NameAndType.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info_NameAndType.java index 076fa95c..54c676db 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info_NameAndType.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestMethod_info_NameAndType.java @@ -34,17 +34,18 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestMethod_info_NameAndType { private static final int ACCESS_FLAG = 0x0000; private static final int NAME_INDEX = 123; @@ -53,54 +54,69 @@ public class TestMethod_info_NameAndType { private static final String CLASS = "Abc"; - @Parameters(name="MethodRef_info to {0} " + CLASS + ".{1} with descriptor \"{2}\"") - public static Object[][] data() { - return new Object[][] { - {"void method", "foo", "(I)V", "foo(int)", "void", "foo(int): void", CLASS + ".foo(int): void"}, - {"regular method", "foo", "(Ljava/lang/String;)Ljava/lang/Object;", "foo(java.lang.String)", "java.lang.Object", "foo(java.lang.String): java.lang.Object", CLASS + ".foo(java.lang.String): java.lang.Object"}, - {"constructor", "", "()V", CLASS + "()", "void", CLASS + "()", CLASS + "." + CLASS + "()"}, - {"static initializer", "", "()V", "static {}", "void", "static {}", CLASS + ".static {}"}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("void method", "foo", "(I)V", "foo(int)", "void", "foo(int): void", CLASS + ".foo(int): void"), + arguments("regular method", "foo", "(Ljava/lang/String;)Ljava/lang/Object;", "foo(java.lang.String)", "java.lang.Object", "foo(java.lang.String): java.lang.Object", CLASS + ".foo(java.lang.String): java.lang.Object"), + arguments("constructor", "", "()V", CLASS + "()", "void", CLASS + "()", CLASS + "." + CLASS + "()"), + arguments("static initializer", "", "()V", "static {}", "void", "static {}", CLASS + ".static {}") + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public String name; - - @Parameter(2) - public String descriptor; - - @Parameter(3) - public String expectedSignature; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(4) - public String expectedReturnType; + @DisplayName("Method_info") + @ParameterizedTest(name="signature for {0} should be {3}") + @MethodSource("dataProvider") + void testGetSignature(String variation, String name, String descriptor, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, descriptor); + assertEquals(expectedSignature, sut.getSignature()); + } - @Parameter(5) - public String expectedUniqueName; + @DisplayName("Method_info") + @ParameterizedTest(name="full signature for {0} should be " + CLASS + ".{3}") + @MethodSource("dataProvider") + void testGetFullSignature(String variation, String name, String descriptor, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, descriptor); + assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); + } - @Parameter(6) - public String expectedFullUniqueName; + @DisplayName("Method_info") + @ParameterizedTest(name="return type for {0} should be {4}") + @MethodSource("dataProvider") + void testGetReturnType(String variation, String name, String descriptor, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, descriptor); + assertEquals(expectedReturnType, sut.getReturnType()); + } - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; + @DisplayName("Method_info") + @ParameterizedTest(name="unique name for {0} should be {5}") + @MethodSource("dataProvider") + void testGetUniqueName(String variation, String name, String descriptor, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, descriptor); + assertEquals(expectedUniqueName, sut.getUniqueName()); + } - private Method_info sut; + @DisplayName("Method_info") + @ParameterizedTest(name="full unique name for {0} should be {6}") + @MethodSource("dataProvider") + void testGetFullUniqueName(String variation, String name, String descriptor, String expectedSignature, String expectedReturnType, String expectedUniqueName, String expectedFullUniqueName) throws IOException { + var sut = createSut(name, descriptor); + assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + } - @Before - public void setUp() throws IOException { - final Classfile mockClassfile = context.mock(Classfile.class); - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); + private Method_info createSut(String name, String descriptor) throws IOException { + var mockClassfile = context.mock(Classfile.class); + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); - final UTF8_info mockName_info = context.mock(UTF8_info.class, "name_info"); - final UTF8_info mockDescriptor_info = context.mock(UTF8_info.class, "descriptor_info"); + var mockName_info = context.mock(UTF8_info.class, "name_info"); + var mockDescriptor_info = context.mock(UTF8_info.class, "descriptor_info"); - final Sequence dataReads = context.sequence("dataReads"); + var dataReads = context.sequence("dataReads"); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -134,31 +150,6 @@ public void setUp() throws IOException { will(returnValue(descriptor)); }}); - sut = new Method_info(mockClassfile, mockIn); - } - - @Test - public void testGetSignature() { - assertEquals(expectedSignature, sut.getSignature()); - } - - @Test - public void testGetFullSignature() { - assertEquals(CLASS + "." + expectedSignature, sut.getFullSignature()); - } - - @Test - public void testGetReturnType() { - assertEquals(expectedReturnType, sut.getReturnType()); - } - - @Test - public void testGetUniqueName() { - assertEquals(expectedUniqueName, sut.getUniqueName()); - } - - @Test - public void testGetFullUniqueName() { - assertEquals(expectedFullUniqueName, sut.getFullUniqueName()); + return new Method_info(mockClassfile, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleExports_exportsFlags.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleExports_exportsFlags.java index 4fe5bbb1..64dc3529 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleExports_exportsFlags.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleExports_exportsFlags.java @@ -34,54 +34,55 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModuleExports_exportsFlags { - @Parameters(name="Module exports with exports flags {0}") - public static Object[][] data() { - return new Object[][] { - {"SYNTHETIC", 0x1000, true, false}, - {"MANDATED", 0x8000, false, true}, - {"all of them", 0x9060, true, true}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("SYNTHETIC", 0x1000, true, false), + arguments("MANDATED", 0x8000, false, true), + arguments("all of them", 0x9060, true, true) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int exportsFlags; - - @Parameter(2) - public boolean isSynthetic; - - @Parameter(3) - public boolean isMandated; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private ModuleExports sut; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="isSynthetic for {0} should be {2}") + @MethodSource("dataProvider") + void testIsSynthetic(String variation, int exportsFlags, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(exportsFlags); + assertEquals(isSynthetic, sut.isSynthetic()); + } - @Before - public void setUp() throws IOException { - final int exportsIndex = 123; - final String exports = "abc"; + @DisplayName("MethodRef_info") + @ParameterizedTest(name="isMandated for {0} should be {3}") + @MethodSource("dataProvider") + void testIsMandated(String variation, int exportsFlags, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(exportsFlags); + assertEquals(isMandated, sut.isMandated()); + } - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); - final Package_info mockPackage_info = context.mock(Package_info.class); + private ModuleExports createSut(int exportsFlags) throws IOException { + var exportsIndex = 123; + var exports = "abc"; + + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + var mockPackage_info = context.mock(Package_info.class); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -98,16 +99,6 @@ public void setUp() throws IOException { will(returnValue(0)); }}); - sut = new ModuleExports(mockConstantPool, mockIn); - } - - @Test - public void testIsSynthetic() { - assertEquals(label, isSynthetic, sut.isSynthetic()); - } - - @Test - public void testIsMandated() { - assertEquals(label, isMandated, sut.isMandated()); + return new ModuleExports(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleOpens_opensFlags.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleOpens_opensFlags.java index bc514d63..90b569ef 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleOpens_opensFlags.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleOpens_opensFlags.java @@ -34,54 +34,55 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModuleOpens_opensFlags { - @Parameters(name="Module opens with opens flags {0}") - public static Object[][] data() { - return new Object[][] { - {"SYNTHETIC", 0x1000, true, false}, - {"MANDATED", 0x8000, false, true}, - {"all of them", 0x9060, true, true}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("SYNTHETIC", 0x1000, true, false), + arguments("MANDATED", 0x8000, false, true), + arguments("all of them", 0x9060, true, true) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int opensFlags; - - @Parameter(2) - public boolean isSynthetic; - - @Parameter(3) - public boolean isMandated; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private ModuleOpens sut; + @DisplayName("ModuleOpens") + @ParameterizedTest(name="isSynthetic for {0} should be {2}") + @MethodSource("dataProvider") + public void testIsSynthetic(String variation, int opensFlags, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(opensFlags); + assertEquals(isSynthetic, sut.isSynthetic()); + } - @Before - public void setUp() throws IOException { - final int opensIndex = 123; - final String opens = "abc"; + @DisplayName("ModuleOpens") + @ParameterizedTest(name="isMandated for {0} should be {3}") + @MethodSource("dataProvider") + public void testIsMandated(String variation, int opensFlags, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(opensFlags); + assertEquals(isMandated, sut.isMandated()); + } - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); - final Package_info mockPackage_info = context.mock(Package_info.class); + private ModuleOpens createSut(int opensFlags) throws IOException { + var opensIndex = 123; + var opens = "abc"; + + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + var mockPackage_info = context.mock(Package_info.class); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -98,16 +99,6 @@ public void setUp() throws IOException { will(returnValue(0)); }}); - sut = new ModuleOpens(mockConstantPool, mockIn); - } - - @Test - public void testIsSynthetic() { - assertEquals(label, isSynthetic, sut.isSynthetic()); - } - - @Test - public void testIsMandated() { - assertEquals(label, isMandated, sut.isMandated()); + return new ModuleOpens(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresFlags.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresFlags.java index 370c1d43..e921c721 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresFlags.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresFlags.java @@ -34,65 +34,76 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModuleRequires_requiresFlags { - @Parameters(name="Module requires with requires flags {0}") - public static Object[][] data() { - return new Object[][] { - {"TRANSTIVE", 0x0020, true, false, false, false}, - {"STATIC_PHASE", 0x0040, false, true, false, false}, - {"SYNTHETIC", 0x1000, false, false, true, false}, - {"MANDATED", 0x8000, false, false, false, true}, - {"all of them", 0x9060, true, true, true, true}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("TRANSTIVE", 0x0020, true, false, false, false), + arguments("STATIC_PHASE", 0x0040, false, true, false, false), + arguments("SYNTHETIC", 0x1000, false, false, true, false), + arguments("MANDATED", 0x8000, false, false, false, true), + arguments("all of them", 0x9060, true, true, true, true) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int requiresFlags; - - @Parameter(2) - public boolean isTransitive; - - @Parameter(3) - public boolean isStaticPhase; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(4) - public boolean isSynthetic; + @DisplayName("ModuleRequires") + @ParameterizedTest(name="isTransitive for {0} should be {2}") + @MethodSource("dataProvider") + public void testIsTransitive(String variation, int requiresFlags, boolean isTransitive, boolean isStaticPhase, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(requiresFlags); + assertEquals(isTransitive, sut.isTransitive()); + } - @Parameter(5) - public boolean isMandated; + @DisplayName("ModuleRequires") + @ParameterizedTest(name="isStaticPhase for {0} should be {3}") + @MethodSource("dataProvider") + public void testIsStaticPhase(String variation, int requiresFlags, boolean isTransitive, boolean isStaticPhase, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(requiresFlags); + assertEquals(isStaticPhase, sut.isStaticPhase()); + } - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; + @DisplayName("ModuleRequires") + @ParameterizedTest(name="isSynthetic for {0} should be {4}") + @MethodSource("dataProvider") + public void testIsSynthetic(String variation, int requiresFlags, boolean isTransitive, boolean isStaticPhase, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(requiresFlags); + assertEquals(isSynthetic, sut.isSynthetic()); + } - private ModuleRequires sut; + @DisplayName("ModuleRequires") + @ParameterizedTest(name="isMandated for {0} should be {5}") + @MethodSource("dataProvider") + public void testIsMandated(String variation, int requiresFlags, boolean isTransitive, boolean isStaticPhase, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(requiresFlags); + assertEquals(isMandated, sut.isMandated()); + } - @Before - public void setUp() throws IOException { - final int requiresIndex = 123; - final String requires = "abc"; - final int requiresVersionIndex = 465; - final String requiresVersion = "blah"; + private ModuleRequires createSut(int requiresFlags) throws IOException { + var requiresIndex = 123; + var requires = "abc"; + var requiresVersionIndex = 465; + var requiresVersion = "blah"; - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); - final Module_info mockModule_info = context.mock(Module_info.class); - final UTF8_info mockUtf8_info = context.mock(UTF8_info.class); + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + var mockModule_info = context.mock(Module_info.class); + var mockUtf8_info = context.mock(UTF8_info.class); context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -113,26 +124,6 @@ public void setUp() throws IOException { will(returnValue(requiresVersion)); }}); - sut = new ModuleRequires(mockConstantPool, mockIn); - } - - @Test - public void testIsTransitive() { - assertEquals(label, isTransitive, sut.isTransitive()); - } - - @Test - public void testIsStaticPhase() { - assertEquals(label, isStaticPhase, sut.isStaticPhase()); - } - - @Test - public void testIsSynthetic() { - assertEquals(label, isSynthetic, sut.isSynthetic()); - } - - @Test - public void testIsMandated() { - assertEquals(label, isMandated, sut.isMandated()); + return new ModuleRequires(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresVersion.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresVersion.java index 752e6b4d..182c8ace 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresVersion.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModuleRequires_requiresVersion.java @@ -34,58 +34,76 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModuleRequires_requiresVersion { - @Parameters(name="Module requires {0}") - public static Object[][] data() { - return new Object[][] { - {"without version", 0, false, null}, - {"with version", 789, true, "version information"}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("without version", 0, false, null), + arguments("with version", 789, true, "version information") + ); } - @Parameter(0) - public String label; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(1) - public int requiresVersionIndex; + @DisplayName("MethodRequires") + @ParameterizedTest(name="requiresVersionIndex for {0} should be {1}") + @MethodSource("dataProvider") + public void testGetRequiresVersionIndex(String variation, int requiresVersionIndex, boolean hasRequiresVersion, String requiresVersion) throws IOException { + var sut = createSut(requiresVersionIndex, requiresVersion); + assertEquals(requiresVersionIndex, sut.getRequiresVersionIndex()); + } - @Parameter(2) - public boolean hasRequiresVersion; + @DisplayName("MethodRequires") + @ParameterizedTest(name="hasRequiresVersion for {0} should be {2}") + @MethodSource("dataProvider") + public void testHasRequiresVersion(String variation, int requiresVersionIndex, boolean hasRequiresVersion, String requiresVersion) throws IOException { + var sut = createSut(requiresVersionIndex, requiresVersion); + assertEquals(hasRequiresVersion, sut.hasRequiresVersion()); + } - @Parameter(3) - public String requiresVersion; + @DisplayName("MethodRequires") + @ParameterizedTest(name="raw requiresVersion for {0} should be present if {2}") + @MethodSource("dataProvider") + public void testGetRawRequiresVersion(String variation, int requiresVersionIndex, boolean hasRequiresVersion, String requiresVersion) throws IOException { + var sut = createSut(requiresVersionIndex, requiresVersion); - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; - - private UTF8_info mockUtf8_info; + var actualRawRequiresVersion = Optional.ofNullable(sut.getRawRequiresVersion()); + assertEquals(hasRequiresVersion, actualRawRequiresVersion.isPresent()); + } - private ModuleRequires sut; + @DisplayName("MethodRequires") + @ParameterizedTest(name="requiresVersion for {0} should be {3}") + @MethodSource("dataProvider") + public void testGetRequiresVersion(String variation, int requiresVersionIndex, boolean hasRequiresVersion, String requiresVersion) throws IOException { + var sut = createSut(requiresVersionIndex, requiresVersion); + assertEquals(requiresVersion, sut.getRequiresVersion()); + } - @Before - public void setUp() throws IOException { - final int requiresIndex = 123; - final String requires = "abc"; - final int requiresFlags = 456; + private ModuleRequires createSut(int requiresVersionIndex, String requiresVersion) throws IOException { + var requiresIndex = 123; + var requires = "abc"; + var requiresFlags = 456; - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final DataInput mockIn = context.mock(DataInput.class); - final Module_info mockModule_info = context.mock(Module_info.class); + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + var mockModule_info = context.mock(Module_info.class); - mockUtf8_info = requiresVersionIndex != 0 ? context.mock(UTF8_info.class) : null; + var mockUtf8_info = requiresVersionIndex != 0 ? context.mock(UTF8_info.class) : null; context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); @@ -108,26 +126,6 @@ public void setUp() throws IOException { } }}); - sut = new ModuleRequires(mockConstantPool, mockIn); - } - - @Test - public void testGetRequiresVersionIndex() { - assertEquals(label, requiresVersionIndex, sut.getRequiresVersionIndex()); - } - - @Test - public void testHasRequiresVersion() { - assertEquals(label, hasRequiresVersion, sut.hasRequiresVersion()); - } - - @Test - public void testGetRawRequiresVersion() { - assertEquals(label, mockUtf8_info, sut.getRawRequiresVersion()); - } - - @Test - public void testGetRequiresVersion() { - assertEquals(label, requiresVersion, sut.getRequiresVersion()); + return new ModuleRequires(mockConstantPool, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleFlags.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleFlags.java index eb969cac..bc250e06 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleFlags.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleFlags.java @@ -32,65 +32,72 @@ package com.jeantessier.classreader.impl; -import com.jeantessier.classreader.Visitable; import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; + +import com.jeantessier.classreader.Visitable; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModule_attribute_moduleFlags { - @Parameters(name="Module with module flags {0}") - public static Object[][] data() { - return new Object[][] { - {"OPEN", 0x0020, true, false, false}, - {"SYNTHETIC", 0x1000, false, true, false}, - {"MANDATED", 0x8000, false, false, true}, - {"all of them", 0x9020, true, true, true}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("OPEN", 0x0020, true, false, false), + arguments("SYNTHETIC", 0x1000, false, true, false), + arguments("MANDATED", 0x8000, false, false, true), + arguments("all of them", 0x9020, true, true, true) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int moduleFlags; - - @Parameter(2) - public boolean isOpen; - - @Parameter(3) - public boolean isSynthetic; - - @Parameter(4) - public boolean isMandated; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private Module_attribute sut; + @DisplayName("Module_attribute") + @ParameterizedTest(name="isOpen for {0} should be {2}") + @MethodSource("dataProvider") + public void testIsOpen(String variation, int moduleFlags, boolean isOpen, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(moduleFlags); + assertEquals(isOpen, sut.isOpen()); + } - @Before - public void setUp() throws IOException { - final int moduleNameIndex = 123; - final String moduleName = "abc"; - final int moduleVersionIndex = 465; - final String moduleVersion = "blah"; + @DisplayName("Module_attribute") + @ParameterizedTest(name="isSynthetic for {0} should be {3}") + @MethodSource("dataProvider") + public void testIsSynthetic(String variation, int moduleFlags, boolean isOpen, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(moduleFlags); + assertEquals(isSynthetic, sut.isSynthetic()); + } - final ConstantPool mockConstantPool = context.mock(ConstantPool.class); - final Visitable mockOwner = context.mock(Visitable.class); - final DataInput mockIn = context.mock(DataInput.class); - final Module_info mockModule_info = context.mock(Module_info.class); - final UTF8_info mockUtf8_info = context.mock(UTF8_info.class); + @DisplayName("Module_attribute") + @ParameterizedTest(name="isMandated for {0} should be {4}") + @MethodSource("dataProvider") + public void testIsMandated(String variation, int moduleFlags, boolean isOpen, boolean isSynthetic, boolean isMandated) throws IOException { + var sut = createSut(moduleFlags); + assertEquals(isMandated, sut.isMandated()); + } + + private Module_attribute createSut(int moduleFlags) throws IOException { + var moduleNameIndex = 123; + var moduleName = "abc"; + var moduleVersionIndex = 465; + var moduleVersion = "blah"; + + var mockConstantPool = context.mock(ConstantPool.class); + var mockOwner = context.mock(Visitable.class); + var mockIn = context.mock(DataInput.class); + var mockModule_info = context.mock(Module_info.class); + var mockUtf8_info = context.mock(UTF8_info.class); context.checking(new Expectations() {{ oneOf (mockIn).readInt(); @@ -117,21 +124,6 @@ public void setUp() throws IOException { will(returnValue(0)); }}); - sut = new Module_attribute(mockConstantPool, mockOwner, mockIn); - } - - @Test - public void testIsOpen() { - assertEquals(label, isOpen, sut.isOpen()); - } - - @Test - public void testIsSynthetic() { - assertEquals(label, isSynthetic, sut.isSynthetic()); - } - - @Test - public void testIsMandated() { - assertEquals(label, isMandated, sut.isMandated()); + return new Module_attribute(mockConstantPool, mockOwner, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleVersion.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleVersion.java index c8c090f2..0239c7f9 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleVersion.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestModule_attribute_moduleVersion.java @@ -32,52 +32,71 @@ package com.jeantessier.classreader.impl; -import com.jeantessier.classreader.Visitable; import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.*; +import java.util.stream.*; + +import com.jeantessier.classreader.Visitable; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestModule_attribute_moduleVersion { - @Parameters(name="Module {0}") - public static Object[][] data() { - return new Object[][] { - {"without version", 0, false, null}, - {"with version", 789, true, "version information"}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("without version", 0, false, null), + arguments("with version", 789, true, "version information") + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int moduleVersionIndex; + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ + setImposteriser(ByteBuddyClassImposteriser.INSTANCE); + }}; - @Parameter(2) - public boolean hasModuleVersion; + @DisplayName("Module_attribute") + @ParameterizedTest(name="moduleVersionIndex for {0} should be {1}") + @MethodSource("dataProvider") + public void testGetModuleVersionIndex(String variation, int moduleVersionIndex, boolean hasModuleVersion, String moduleVersion) throws IOException { + var sut = createSut(moduleVersionIndex, moduleVersion); + assertEquals(moduleVersionIndex, sut.getModuleVersionIndex()); + } - @Parameter(3) - public String moduleVersion; + @DisplayName("Module_attribute") + @ParameterizedTest(name="hasModuleVersion for {0} should be {2}") + @MethodSource("dataProvider") + public void testHasModuleVersion(String variation, int moduleVersionIndex, boolean hasModuleVersion, String moduleVersion) throws IOException { + var sut = createSut(moduleVersionIndex, moduleVersion); + assertEquals(hasModuleVersion, sut.hasModuleVersion()); + } - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ - setImposteriser(ByteBuddyClassImposteriser.INSTANCE); - }}; + @DisplayName("Module_attribute") + @ParameterizedTest(name="raw moduleVersion for {0} should be present if {2}") + @MethodSource("dataProvider") + public void testGetRawModuleVersion(String variation, int moduleVersionIndex, boolean hasModuleVersion, String moduleVersion) throws IOException { + var sut = createSut(moduleVersionIndex, moduleVersion); - private UTF8_info mockUtf8_info; + var actualRawModuleVersion = Optional.ofNullable(sut.getRawModuleVersion()); + assertEquals(hasModuleVersion, actualRawModuleVersion.isPresent()); + } - private Module_attribute sut; + @DisplayName("Module_attribute") + @ParameterizedTest(name="moduleVersion for {0} should be {3}") + @MethodSource("dataProvider") + public void testGetModuleVersion(String variation, int moduleVersionIndex, boolean hasModuleVersion, String moduleVersion) throws IOException { + var sut = createSut(moduleVersionIndex, moduleVersion); + assertEquals(moduleVersion, sut.getModuleVersion()); + } - @Before - public void setUp() throws IOException { + private Module_attribute createSut(int moduleVersionIndex, String moduleVersion) throws IOException { final int moduleNameIndex = 123; final String moduleName = "abc"; final int moduleFlags = 456; @@ -87,7 +106,7 @@ public void setUp() throws IOException { final DataInput mockIn = context.mock(DataInput.class); final Module_info mockModule_info = context.mock(Module_info.class); - mockUtf8_info = moduleVersionIndex != 0 ? context.mock(UTF8_info.class) : null; + var mockUtf8_info = moduleVersionIndex != 0 ? context.mock(UTF8_info.class) : null; context.checking(new Expectations() {{ oneOf (mockIn).readInt(); @@ -116,26 +135,6 @@ public void setUp() throws IOException { will(returnValue(0)); }}); - sut = new Module_attribute(mockConstantPool, mockOwner, mockIn); - } - - @Test - public void testGetModuleVersionIndex() { - assertEquals(label, moduleVersionIndex, sut.getModuleVersionIndex()); - } - - @Test - public void testHasModuleVersion() { - assertEquals(label, hasModuleVersion, sut.hasModuleVersion()); - } - - @Test - public void testGetRawModuleVersion() { - assertEquals(label, mockUtf8_info, sut.getRawModuleVersion()); - } - - @Test - public void testGetModuleVersion() { - assertEquals(label, moduleVersion, sut.getModuleVersion()); + return new Module_attribute(mockConstantPool, mockOwner, mockIn); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestStackMapFrameFactory_create.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestStackMapFrameFactory_create.java index 947e21c0..cee96f1a 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestStackMapFrameFactory_create.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestStackMapFrameFactory_create.java @@ -34,131 +34,110 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; import java.util.*; +import java.util.stream.*; -import static org.junit.Assert.*; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestStackMapFrameFactory_create { - @Parameters(name="Stack Map Frame from tag {0}") - public static Object[][] data() { - return new Object[][] { - {"SAME (min)", 0, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class}, - {"SAME (max)", 63, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM (min)", 64, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM (max)", 127, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class}, - {"SAME_LOCALS_1_STACK_ITEM_EXTENDED", 247, 456, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrameExtended.class}, - {"CHOP (min)", 248, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class}, - {"CHOP (min)", 250, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class}, - {"SAME_FRAME_EXTENDED", 251, 456, null, Collections.emptyList(), null, Collections.emptyList(), SameFrameExtended.class}, - {"APPEND (252 - 251 = 1)", 252, 456, null, List.of("TOP1"), null, Collections.emptyList(), AppendFrame.class}, - {"APPEND (253 - 251 = 2)", 253, 456, null, List.of("TOP1", "TOP2"), null, Collections.emptyList(), AppendFrame.class}, - {"APPEND (253 - 251 = 3)", 254, 456, null, List.of("TOP1", "TOP2", "TOP3"), null, Collections.emptyList(), AppendFrame.class}, - {"FULL_FRAME (empties)", 255, 456, 0, Collections.emptyList(), 0, Collections.emptyList(), FullFrame.class}, - {"FULL_FRAME (locals only)", 255, 456, 2, List.of("TOP1", "TOP2"), 0, Collections.emptyList(), FullFrame.class}, - {"FULL_FRAME (stack only)", 255, 456, 0, Collections.emptyList(), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class}, - {"FULL_FRAME (locals and stack)", 255, 456, 2, List.of("TOP1", "TOP2"), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("SAME (min)", 0, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class), + arguments("SAME (max)", 63, null, null, Collections.emptyList(), null, Collections.emptyList(), SameFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM (min)", 64, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM (max)", 127, null, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrame.class), + arguments("SAME_LOCALS_1_STACK_ITEM_EXTENDED", 247, 456, null, Collections.emptyList(), null, Collections.singleton("TOP"), SameLocals1StackItemFrameExtended.class), + arguments("CHOP (min)", 248, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class), + arguments("CHOP (min)", 250, 456, null, Collections.emptyList(), null, Collections.emptyList(), ChopFrame.class), + arguments("SAME_FRAME_EXTENDED", 251, 456, null, Collections.emptyList(), null, Collections.emptyList(), SameFrameExtended.class), + arguments("APPEND (252 - 251 = 1)", 252, 456, null, List.of("TOP1"), null, Collections.emptyList(), AppendFrame.class), + arguments("APPEND (253 - 251 = 2)", 253, 456, null, List.of("TOP1", "TOP2"), null, Collections.emptyList(), AppendFrame.class), + arguments("APPEND (253 - 251 = 3)", 254, 456, null, List.of("TOP1", "TOP2", "TOP3"), null, Collections.emptyList(), AppendFrame.class), + arguments("FULL_FRAME (empties)", 255, 456, 0, Collections.emptyList(), 0, Collections.emptyList(), FullFrame.class), + arguments("FULL_FRAME (locals only)", 255, 456, 2, List.of("TOP1", "TOP2"), 0, Collections.emptyList(), FullFrame.class), + arguments("FULL_FRAME (stack only)", 255, 456, 0, Collections.emptyList(), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class), + arguments("FULL_FRAME (locals and stack)", 255, 456, 2, List.of("TOP1", "TOP2"), 3, List.of("TOP3", "TOP4", "TOP5"), FullFrame.class) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int frameType; - - @Parameter(2) - public Integer offsetDelta; - - @Parameter(3) - public Integer numberOfLocals; - - @Parameter(4) - public Collection locals; - - @Parameter(5) - public Integer numberOfStackItems; - - @Parameter(6) - public Collection stacks; - - @Parameter(7) - public Class expectedClass; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private VerificationTypeInfoFactory mockVerificationTypeInfoFactory; - private ConstantPool mockConstantPool; - private DataInput mockIn; - - private StackMapFrameFactory sut; - - @Before - public void setUp() throws IOException { - mockVerificationTypeInfoFactory = context.mock(VerificationTypeInfoFactory.class); - mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); + @DisplayName("StackMapFrameFactory") + @ParameterizedTest(name="for {0} should be {7} with type {1}") + @MethodSource("dataProvider") + public void testCreate(String variation, int frameType, Integer offsetDelta, Integer numberOfLocals, Collection locals, Integer numberOfStackItems, Collection stacks, Class expectedClass) throws IOException { + // Given + var mockVerificationTypeInfoFactory = context.mock(VerificationTypeInfoFactory.class); + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + // and context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedByte(); - will(returnValue(frameType)); + will(returnValue(frameType)); }}); + // and if (offsetDelta != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); - will(returnValue(offsetDelta)); + will(returnValue(offsetDelta)); }}); } + // and if (numberOfLocals != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); - will(returnValue(numberOfLocals)); + will(returnValue(numberOfLocals)); }}); } + // and for (String localName : locals) { final VerificationTypeInfo mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, localName); context.checking(new Expectations() {{ oneOf (mockVerificationTypeInfoFactory).create(mockConstantPool, mockIn); - will(returnValue(mockVerificationTypeInfo)); + will(returnValue(mockVerificationTypeInfo)); }}); } + // and if (numberOfStackItems != null) { context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedShort(); - will(returnValue(numberOfStackItems)); + will(returnValue(numberOfStackItems)); }}); } + // and for (String stackName : stacks) { final VerificationTypeInfo mockVerificationTypeInfo = context.mock(VerificationTypeInfo.class, stackName); context.checking(new Expectations() {{ oneOf (mockVerificationTypeInfoFactory).create(mockConstantPool, mockIn); - will(returnValue(mockVerificationTypeInfo)); + will(returnValue(mockVerificationTypeInfo)); }}); } - sut = new StackMapFrameFactory(mockVerificationTypeInfoFactory); - } + // and + var sut = new StackMapFrameFactory(mockVerificationTypeInfoFactory); - @Test - public void testCreate() throws IOException { + // When var actualStackMapFrame = sut.create(mockConstantPool, mockIn); - assertEquals(label, expectedClass, actualStackMapFrame.getClass()); - assertEquals(label, frameType, actualStackMapFrame.getFrameType()); + // Then + assertEquals(expectedClass, actualStackMapFrame.getClass()); + assertEquals(frameType, actualStackMapFrame.getFrameType()); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationTypeInfoFactory_create.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationTypeInfoFactory_create.java index 813acd3e..ea72a94d 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationTypeInfoFactory_create.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationTypeInfoFactory_create.java @@ -34,68 +34,53 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.assertEquals; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestVerificationTypeInfoFactory_create { - @Parameters(name="VerificationType from tag {0}") - public static Object[][] data() { - return new Object[][] { - {"ITEM_Top", 0, null, null, TopVariableInfo.class}, - {"ITEM_Integer", 1, null, null, IntegerVariableInfo.class}, - {"ITEM_Float", 2, null, null, FloatVariableInfo.class}, - {"ITEM_Null", 5, null, null, NullVariableInfo.class}, - {"ITEM_UninitializedThis", 6, null, null, UninitializedThisVariableInfo.class}, - {"ITEM_Object", 7, 123, Class_info.class, ObjectVariableInfo.class}, - {"ITEM_Uninitialized", 8, 456, null, UninitializedVariableInfo.class}, - {"ITEM_Long", 4, null, null, LongVariableInfo.class}, - {"ITEM_Double", 3, null, null, DoubleVariableInfo.class}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("ITEM_Top", 0, null, null, TopVariableInfo.class), + arguments("ITEM_Integer", 1, null, null, IntegerVariableInfo.class), + arguments("ITEM_Float", 2, null, null, FloatVariableInfo.class), + arguments("ITEM_Null", 5, null, null, NullVariableInfo.class), + arguments("ITEM_UninitializedThis", 6, null, null, UninitializedThisVariableInfo.class), + arguments("ITEM_Object", 7, 123, Class_info.class, ObjectVariableInfo.class), + arguments("ITEM_Uninitialized", 8, 456, null, UninitializedVariableInfo.class), + arguments("ITEM_Long", 4, null, null, LongVariableInfo.class), + arguments("ITEM_Double", 3, null, null, DoubleVariableInfo.class) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int tag; - - @Parameter(2) - public Integer indexOrOffset; - - @Parameter(3) - public Class constantPoolEntryClass; - - @Parameter(4) - public Class expectedClass; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private ConstantPool mockConstantPool; - private DataInput mockIn; - - private final VerificationTypeInfoFactory sut = new VerificationTypeInfoFactory(); - - @Before - public void setUp() throws IOException { - mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); + @DisplayName("VerificationTypeInfoFactory") + @ParameterizedTest(name="for {0} should be {4} with tag {1}") + @MethodSource("dataProvider") + public void testCreate(String variation, int tag, Integer indexOrOffset, Class constantPoolEntryClass, Class expectedClass) throws IOException { + // Given + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + // and context.checking(new Expectations() {{ oneOf (mockIn).readUnsignedByte(); will(returnValue(tag)); }}); + // and // for ObjectVariableInfo's cpool_index and UninitializedVariableInfo's offset if (indexOrOffset != null) { context.checking(new Expectations() {{ @@ -104,6 +89,7 @@ public void setUp() throws IOException { }}); } + // and // for ObjectVariableInfo's cpool_index if (constantPoolEntryClass != null) { final ConstantPoolEntry mockConstantPoolEntry = context.mock(constantPoolEntryClass); @@ -112,13 +98,15 @@ public void setUp() throws IOException { will(returnValue(mockConstantPoolEntry)); }}); } - } - @Test - public void testCreate() throws IOException { + // and + var sut = new VerificationTypeInfoFactory(); + + // When var actualVerificationTypeInfo = sut.create(mockConstantPool, mockIn); - assertEquals(label, expectedClass, actualVerificationTypeInfo.getClass()); - assertEquals(label, tag, actualVerificationTypeInfo.getTag()); + // Then + assertEquals(expectedClass, actualVerificationTypeInfo.getClass()); + assertEquals(tag, actualVerificationTypeInfo.getTag()); } } diff --git a/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationType_create.java b/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationType_create.java index 7b3fd46f..65efb10f 100644 --- a/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationType_create.java +++ b/lib/src/test/java/com/jeantessier/classreader/impl/TestVerificationType_create.java @@ -34,63 +34,47 @@ import org.jmock.*; import org.jmock.imposters.*; -import org.jmock.integration.junit4.*; -import org.junit.*; -import org.junit.runner.*; -import org.junit.runners.*; +import org.jmock.junit5.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.extension.*; +import org.junit.jupiter.params.*; +import org.junit.jupiter.params.provider.*; import java.io.*; +import java.util.stream.*; -import static org.junit.Assert.assertEquals; -import static org.junit.runners.Parameterized.*; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.params.provider.Arguments.*; -@RunWith(Parameterized.class) public class TestVerificationType_create { - @Parameters(name="VerificationType from tag {0}") - public static Object[][] data() { - return new Object[][] { - {"ITEM_Top", 0, null, null, TopVariableInfo.class}, - {"ITEM_Integer", 1, null, null, IntegerVariableInfo.class}, - {"ITEM_Float", 2, null, null, FloatVariableInfo.class}, - {"ITEM_Null", 5, null, null, NullVariableInfo.class}, - {"ITEM_UninitializedThis", 6, null, null, UninitializedThisVariableInfo.class}, - {"ITEM_Object", 7, 123, Class_info.class, ObjectVariableInfo.class}, - {"ITEM_Uninitialized", 8, 456, null, UninitializedVariableInfo.class}, - {"ITEM_Long", 4, null, null, LongVariableInfo.class}, - {"ITEM_Double", 3, null, null, DoubleVariableInfo.class}, - }; + static Stream dataProvider() { + return Stream.of( + arguments("ITEM_Top", 0, null, null, TopVariableInfo.class), + arguments("ITEM_Integer", 1, null, null, IntegerVariableInfo.class), + arguments("ITEM_Float", 2, null, null, FloatVariableInfo.class), + arguments("ITEM_Null", 5, null, null, NullVariableInfo.class), + arguments("ITEM_UninitializedThis", 6, null, null, UninitializedThisVariableInfo.class), + arguments("ITEM_Object", 7, 123, Class_info.class, ObjectVariableInfo.class), + arguments("ITEM_Uninitialized", 8, 456, null, UninitializedVariableInfo.class), + arguments("ITEM_Long", 4, null, null, LongVariableInfo.class), + arguments("ITEM_Double", 3, null, null, DoubleVariableInfo.class) + ); } - @Parameter(0) - public String label; - - @Parameter(1) - public int tag; - - @Parameter(2) - public Integer indexOrOffset; - - @Parameter(3) - public Class constantPoolEntryClass; - - @Parameter(4) - public Class expectedClass; - - @Rule - public JUnitRuleMockery context = new JUnitRuleMockery() {{ + @RegisterExtension + JUnit5Mockery context = new JUnit5Mockery() {{ setImposteriser(ByteBuddyClassImposteriser.INSTANCE); }}; - private ConstantPool mockConstantPool; - private DataInput mockIn; - - private VerificationType sut; - - @Before - public void setUp() throws IOException { - mockConstantPool = context.mock(ConstantPool.class); - mockIn = context.mock(DataInput.class); + @DisplayName("VerificationType") + @ParameterizedTest(name="for {0} should be {4} with tag {1}") + @MethodSource("dataProvider") + public void testCreate(String variation, int tag, Integer indexOrOffset, Class constantPoolEntryClass, Class expectedClass) throws IOException { + // Given + var mockConstantPool = context.mock(ConstantPool.class); + var mockIn = context.mock(DataInput.class); + // and // for ObjectVariableInfo's cpool_index and UninitializedVariableInfo's offset if (indexOrOffset != null) { context.checking(new Expectations() {{ @@ -99,6 +83,7 @@ public void setUp() throws IOException { }}); } + // and // for ObjectVariableInfo's cpool_index if (constantPoolEntryClass != null) { final ConstantPoolEntry mockConstantPoolEntry = context.mock(constantPoolEntryClass); @@ -108,15 +93,14 @@ public void setUp() throws IOException { }}); } - // And - sut = VerificationType.forTag(tag); - } + // and + var sut = VerificationType.forTag(tag); - @Test - public void testCreate() throws IOException { + // When var actualVerificationTypeInfo = sut.create(mockConstantPool, mockIn); - assertEquals(label, expectedClass, actualVerificationTypeInfo.getClass()); - assertEquals(label, tag, actualVerificationTypeInfo.getTag()); + // Then + assertEquals(expectedClass, actualVerificationTypeInfo.getClass()); + assertEquals(tag, actualVerificationTypeInfo.getTag()); } }