Migrate test baseline to JUnit 5 platform

Author: 8Keep

common.gradle

@@ -38,9 +38,12 @@ repositories {
 
 dependencies {
     // Adding dependencies here will add the dependencies to each subproject.
-    testImplementation libs.junit4
+    testImplementation platform(libs.junit.bom)
+    testImplementation libs.junit.jupiter
     testImplementation libs.mokito.core
+    testImplementation libs.mokito.junit.jupiter
     testImplementation libs.groovy.test
+    testRuntimeOnly libs.junit.platform.launcher
 }
 
 // Uncomment if you want to see the status of every test that is run and
@@ -76,6 +79,7 @@ javadoc {
 }
 
 test {
+    useJUnitPlatform()
     testLogging {
         exceptionFormat = 'full'
     }
@@ -227,4 +231,4 @@ tasks.withType(Checkstyle) {
         html.required.set(true)
     }
     include("**/com/jme3/renderer/**/*.java")
-}
+}

gradle/libs.versions.toml

@@ -21,7 +21,9 @@ jbullet = "com.github.stephengold:jbullet:1.0.3"
 jinput = "net.java.jinput:jinput:2.0.9"
 jna = "net.java.dev.jna:jna:5.10.0"
 jnaerator-runtime = "com.nativelibs4java:jnaerator-runtime:0.12"
-junit4 = "junit:junit:4.13.2"
+junit-bom = "org.junit:junit-bom:5.12.2"
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
 lwjgl2 = "org.jmonkeyengine:lwjgl:2.9.5"
 lwjgl3-awt = "org.jmonkeyengine:lwjgl3-awt:0.2.4"
 
@@ -35,6 +37,7 @@ lwjgl3-opengl   = { module = "org.lwjgl:lwjgl-opengl",   version.ref = "lwjgl3"
 lwjgl3-sdl      = { module = "org.lwjgl:lwjgl-sdl",      version.ref = "lwjgl3" }
 
 mokito-core = "org.mockito:mockito-core:3.12.4"
+mokito-junit-jupiter = "org.mockito:mockito-junit-jupiter:3.12.4"
 
 nifty                  = { module = "com.github.nifty-gui:nifty",                  version.ref = "nifty" }
 nifty-default-controls = { module = "com.github.nifty-gui:nifty-default-controls", version.ref = "nifty" }

jme3-core/src/test/java/com/jme3/material/MaterialTest.java

@@ -47,12 +47,12 @@
 
 import java.util.Arrays;
 import java.util.EnumSet;
-import static org.junit.Assert.*;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-@RunWith(MockitoJUnitRunner.class)
 public class MaterialTest {
 
     private Material material;
@@ -65,16 +65,18 @@ public EnumSet<Caps> getCaps() {
         }
     });
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testSelectNonExistentTechnique() {
         material("Common/MatDefs/Gui/Gui.j3md");
-        material.selectTechnique("Doesn't Exist", renderManager);
+        assertThrows(IllegalArgumentException.class,
+                () -> material.selectTechnique("Doesn't Exist", renderManager));
     }
 
-    @Test(expected = UnsupportedOperationException.class)
+    @Test
     public void testSelectDefaultTechnique_NoCaps() {
         material("Common/MatDefs/Gui/Gui.j3md");
-        material.selectTechnique("Default", renderManager);
+        assertThrows(UnsupportedOperationException.class,
+                () -> material.selectTechnique("Default", renderManager));
     }
 
     @Test

jme3-core/src/test/java/com/jme3/material/plugins/J3MLoaderTest.java

@@ -12,23 +12,23 @@
 import com.jme3.texture.Texture;
 import java.io.IOException;
 import java.util.EnumSet;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.verify;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verify;
 
 /**
  * @author Daniel Johansson
  * @since 2015-07-20
  */
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class J3MLoaderTest {
 
     private J3MLoader j3MLoader;
@@ -45,13 +45,13 @@ public class J3MLoaderTest {
     @Mock
     private MaterialDef materialDef;
 
-    @Before
+    @BeforeEach
     @SuppressWarnings("unchecked")
     public void setUp() throws Exception {
         when(assetKey.getExtension()).thenReturn(".j3m");
         when(assetInfo.getManager()).thenReturn(assetManager);
         when(assetInfo.getKey()).thenReturn(assetKey);
-        when(assetManager.loadAsset(any(AssetKey.class))).thenReturn(materialDef);
+        Mockito.lenient().when(assetManager.loadAsset(any(AssetKey.class))).thenReturn(materialDef);
 
         j3MLoader = new J3MLoader();
     }

jme3-core/src/test/java/com/jme3/material/plugins/LoadJ3mdTest.java

@@ -39,12 +39,11 @@
 import com.jme3.shader.Shader;
 import com.jme3.system.*;
 import java.util.*;
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-@RunWith(MockitoJUnitRunner.class)
 public class LoadJ3mdTest {
 
     private Material material;
@@ -57,22 +56,22 @@ public EnumSet<Caps> getCaps() {
         }
     });
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testBadBooleans1() {
         supportGlsl(100);
-        material("bad-booleans1.j3md"); // DepthTest yes
+        assertThrows(IllegalArgumentException.class, () -> material("bad-booleans1.j3md")); // DepthTest yes
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testBadBooleans2() {
         supportGlsl(100);
-        material("bad-booleans2.j3md"); // DepthWrite on
+        assertThrows(IllegalArgumentException.class, () -> material("bad-booleans2.j3md")); // DepthWrite on
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testBadBooleans3() {
         supportGlsl(100);
-        material("bad-booleans3.j3md"); // Wireframe true
+        assertThrows(IllegalArgumentException.class, () -> material("bad-booleans3.j3md")); // Wireframe true
     }
 
     @Test

jme3-core/src/test/java/com/jme3/scene/threadwarden/SceneGraphThreadWardenGeometryExtendedTest.java

@@ -5,40 +5,34 @@
 import com.jme3.scene.Mesh;
 import com.jme3.scene.Node;
 import com.jme3.scene.shape.Box;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.mockito.Mockito;
-
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.ThreadFactory;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Mockito;
 
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 /**
  * Parameterized tests for SceneGraphThreadWarden class with Geometry objects.
  * These tests verify that various scene graph mutations are properly checked for thread safety.
  */
-@RunWith(Parameterized.class)
 public class SceneGraphThreadWardenGeometryExtendedTest {
 
     private static ExecutorService executorService;
 
-    private final String testName;
-    private final Consumer<Geometry> action;
-
     @SuppressWarnings({"ReassignedVariable", "AssertWithSideEffects"})
-    @BeforeClass
+    @BeforeAll
     public static void setupClass() {
         // Make sure assertions are enabled
         boolean assertsEnabled = false;
@@ -48,70 +42,46 @@ public static void setupClass() {
         }
     }
 
-    @Before
+    @BeforeEach
     public void setup() {
         executorService = newSingleThreadDaemonExecutor();
     }
 
-    @After
+    @AfterEach
     public void tearDown() {
         executorService.shutdown();
         SceneGraphThreadWarden.reset();
     }
 
-    /**
-     * Constructor for the parameterized test.
-     * 
-     * @param testName A descriptive name for the test
-     * @param action The action to perform on the spatial
-     */
-    public SceneGraphThreadWardenGeometryExtendedTest(String testName, Consumer<Geometry> action) {
-        this.testName = testName;
-        this.action = action;
-    }
-
     /**
      * Define the parameters for the test.
      * Each parameter is a pair of (test name, action to perform on spatial).
      */
-    @Parameterized.Parameters(name = "{0}")
-    public static Collection<Object[]> data() {
+    static Stream<Arguments> data() {
         Material mockMaterial = Mockito.mock(Material.class);
         Box box = new Box(1, 1, 1);
 
-        return Arrays.asList(new Object[][] {
-            { 
-                "setMaterial", 
-                (Consumer<Geometry>) spatial -> spatial.setMaterial(mockMaterial)
-            },
-            { 
-                "setMesh", 
-                (Consumer<Geometry>) spatial -> spatial.setMesh(box)
-            },
-            { 
-                "setLodLevel", 
-                (Consumer<Geometry>) spatial -> {
-                    // Need to set a mesh with LOD levels first
+        return Stream.of(
+                Arguments.of("setMaterial", (Consumer<Geometry>) spatial -> spatial.setMaterial(mockMaterial)),
+                Arguments.of("setMesh", (Consumer<Geometry>) spatial -> spatial.setMesh(box)),
+                Arguments.of("setLodLevel", (Consumer<Geometry>) spatial -> {
                     Mesh mesh = new Box(1, 1, 1);
                     mesh.setLodLevels(new com.jme3.scene.VertexBuffer[]{
-                        mesh.getBuffer(com.jme3.scene.VertexBuffer.Type.Index)
+                            mesh.getBuffer(com.jme3.scene.VertexBuffer.Type.Index)
                     });
                     spatial.setMesh(mesh);
                     spatial.setLodLevel(0);
-                }
-            },
-            { 
-                "removeFromParent", 
-                (Consumer<Geometry>) Geometry::removeFromParent
-            }
-        });
+                }),
+                Arguments.of("removeFromParent", (Consumer<Geometry>) Geometry::removeFromParent)
+        );
     }
 
     /**
      * Test that scene graph mutation is fine on the main thread when the object is attached to the root.
      */
-    @Test
-    public void testMutationOnMainThreadOnAttachedObject() {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("data")
+    public void testMutationOnMainThreadOnAttachedObject(String testName, Consumer<Geometry> action) {
         Node rootNode = new Node("root");
         SceneGraphThreadWarden.setup(rootNode);
 
@@ -126,8 +96,9 @@ public void testMutationOnMainThreadOnAttachedObject() {
     /**
      * Test that scene graph mutation is fine on the main thread when the object is not attached to the root.
      */
-    @Test
-    public void testMutationOnMainThreadOnDetachedObject() {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("data")
+    public void testMutationOnMainThreadOnDetachedObject(String testName, Consumer<Geometry> action) {
         Node rootNode = new Node("root");
         SceneGraphThreadWarden.setup(rootNode);
 
@@ -141,8 +112,10 @@ public void testMutationOnMainThreadOnDetachedObject() {
     /**
      * Test that scene graph mutation is fine on a non-main thread when the object is not attached to the root.
      */
-    @Test
-    public void testMutationOnNonMainThreadOnDetachedObject() throws ExecutionException, InterruptedException {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("data")
+    public void testMutationOnNonMainThreadOnDetachedObject(String testName, Consumer<Geometry> action)
+            throws ExecutionException, InterruptedException {
         Node rootNode = new Node("root");
         SceneGraphThreadWarden.setup(rootNode);
 
@@ -162,8 +135,10 @@ public void testMutationOnNonMainThreadOnDetachedObject() throws ExecutionExcept
     /**
      * Test that scene graph mutation is not allowed on a non-main thread when the object is attached to the root.
      */
-    @Test
-    public void testMutationOnNonMainThreadOnAttachedObject() throws InterruptedException {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("data")
+    public void testMutationOnNonMainThreadOnAttachedObject(String testName, Consumer<Geometry> action)
+            throws InterruptedException {
         Node rootNode = new Node("root");
         SceneGraphThreadWarden.setup(rootNode);
 
@@ -182,8 +157,8 @@ public void testMutationOnNonMainThreadOnAttachedObject() throws InterruptedExce
             fail("Expected an IllegalThreadSceneGraphMutation exception");
         } catch (ExecutionException e) {
             // This is expected - verify it's the right exception type
-            assertTrue("Expected IllegalThreadSceneGraphMutation, got: " + e.getCause().getClass().getName(),
-                    e.getCause() instanceof IllegalThreadSceneGraphMutation);
+            assertTrue(e.getCause() instanceof IllegalThreadSceneGraphMutation,
+                    "Expected IllegalThreadSceneGraphMutation, got: " + e.getCause().getClass().getName());
         }
     }
 
@@ -204,4 +179,4 @@ private static ThreadFactory daemonThreadFactory() {
             return t;
         };
     }
-}
+}