Switch non-integration tests to JUnit 5 (#1120)

ntcore/src/test/java/edu/wpi/first/networktables/ConnectionListenerTest.java

@@ -44,6 +44,7 @@ class ConnectionListenerTest {
   /**
    * Connect to the server.
    */
+  @SuppressWarnings("PMD.AvoidUsingHardCodedIP")
   private void connect() {
     m_serverInst.startServer("connectionlistenertest.ini", "127.0.0.1", 10000);
     m_clientInst.startClient("127.0.0.1", 10000);
@@ -112,6 +113,7 @@ class ConnectionListenerTest {
 
   @Test
   @DisabledOnOs(OS.WINDOWS)
+  @SuppressWarnings("PMD.AvoidUsingHardCodedIP")
   void testThreaded() {
     m_serverInst.startServer("connectionlistenertest.ini", "127.0.0.1", 10000);
     List<ConnectionNotification> events = new ArrayList<>();

ntcore/src/test/java/edu/wpi/first/networktables/EntryListenerTest.java

@@ -10,14 +10,21 @@ package edu.wpi.first.networktables;
 import java.util.ArrayList;
 import java.util.List;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class EntryListenerTest extends TestCase {
-  NetworkTableInstance m_serverInst;
-  NetworkTableInstance m_clientInst;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
-  @Override
-  protected void setUp() throws Exception {
+class EntryListenerTest {
+  private NetworkTableInstance m_serverInst;
+  private NetworkTableInstance m_clientInst;
+
+  @BeforeEach
+  void setUp() {
     m_serverInst = NetworkTableInstance.create();
     m_serverInst.setNetworkIdentity("server");
 
@@ -25,12 +32,13 @@ public class EntryListenerTest extends TestCase {
     m_clientInst.setNetworkIdentity("client");
   }
 
-  @Override
-  protected void tearDown() throws Exception {
+  @AfterEach
+  void tearDown() {
     m_clientInst.close();
     m_serverInst.close();
   }
 
+  @SuppressWarnings("PMD.AvoidUsingHardCodedIP")
   private void connect() {
     m_serverInst.startServer("connectionlistenertest.ini", "127.0.0.1", 10000);
     m_clientInst.startClient("127.0.0.1", 10000);
@@ -51,7 +59,8 @@ public class EntryListenerTest extends TestCase {
   /**
    * Test prefix with a new remote.
    */
-  public void testPrefixNewRemote() {
+  @Test
+  void testPrefixNewRemote() {
     connect();
     List<EntryNotification> events = new ArrayList<>();
     final int handle = m_serverInst.addEntryListener("/foo", events::add,
@@ -70,11 +79,13 @@ public class EntryListenerTest extends TestCase {
     assertTrue(m_serverInst.waitForEntryListenerQueue(1.0));
 
     // Check the event
-    assertEquals(events.size(), 1);
-    assertEquals(events.get(0).listener, handle);
-    assertEquals(events.get(0).getEntry(), m_serverInst.getEntry("/foo/bar"));
-    assertEquals(events.get(0).name, "/foo/bar");
-    assertEquals(events.get(0).value, NetworkTableValue.makeDouble(1.0));
-    assertEquals(events.get(0).flags, EntryListenerFlags.kNew);
+    assertAll("Event",
+        () -> assertEquals(1, events.size()),
+        () -> assertEquals(handle, events.get(0).listener),
+        () -> assertEquals(m_serverInst.getEntry("/foo/bar"), events.get(0).getEntry()),
+        () -> assertEquals("/foo/bar", events.get(0).name),
+        () -> assertEquals(NetworkTableValue.makeDouble(1.0), events.get(0).value),
+        () -> assertEquals(EntryListenerFlags.kNew, events.get(0).flags)
+    );
   }
 }

ntcore/src/test/java/edu/wpi/first/networktables/JNITest.java

@@ -7,11 +7,11 @@
 
 package edu.wpi.first.networktables;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-public class JNITest {
+class JNITest {
   @Test
-  public void jniLinkTest() {
+  void jniLinkTest() {
     // Test to verify that the JNI test link works correctly.
     int inst = NetworkTablesJNI.getDefaultInstance();
     NetworkTablesJNI.flush(inst);

ntcore/src/test/java/edu/wpi/first/networktables/LoggerTest.java

@@ -10,25 +10,29 @@ package edu.wpi.first.networktables;
 import java.util.ArrayList;
 import java.util.List;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class LoggerTest extends TestCase {
-  NetworkTableInstance m_clientInst;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
 
-  @Override
-  protected void setUp() throws Exception {
+class LoggerTest {
+  private NetworkTableInstance m_clientInst;
+
+  @BeforeEach
+  protected void setUp() {
     m_clientInst = NetworkTableInstance.create();
   }
 
-  @Override
-  protected void tearDown() throws Exception {
+  @AfterEach
+  protected void tearDown() {
     m_clientInst.close();
   }
 
-  /**
-   * Test the logger.
-   */
-  public void testLogger() {
+  @Test
+  @SuppressWarnings("PMD.AvoidUsingHardCodedIP")
+  void addMessageTest() {
     List<LogMessage> msgs = new ArrayList<>();
     m_clientInst.addLogger(msgs::add, LogMessage.kInfo, 100);
 

ntcore/src/test/java/edu/wpi/first/networktables/NetworkTableTest.java

@@ -7,68 +7,74 @@
 
 package edu.wpi.first.networktables;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Stream;
 
-import junit.framework.TestCase;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
-public class NetworkTableTest extends TestCase {
-  public void testBasenameKey() {
-    assertEquals("simple", NetworkTable.basenameKey("simple"));
-    assertEquals("simple", NetworkTable.basenameKey("one/two/many/simple"));
-    assertEquals("simple",
-                 NetworkTable.basenameKey("//////an/////awful/key////simple"));
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class NetworkTableTest {
+  private static Stream<Arguments> basenameKeyArguments() {
+    return Stream.of(
+        Arguments.of("simple", "simple"),
+        Arguments.of("simple", "one/two/many/simple"),
+        Arguments.of("simple", "//////an/////awful/key////simple")
+    );
   }
 
-  public void testNormalizeKeySlash() {
-    assertEquals("/", NetworkTable.normalizeKey("///"));
-    assertEquals("/no/normal/req", NetworkTable.normalizeKey("/no/normal/req"));
-    assertEquals("/no/leading/slash",
-                 NetworkTable.normalizeKey("no/leading/slash"));
-    assertEquals(
-        "/what/an/awful/key/",
-        NetworkTable.normalizeKey("//////what////an/awful/////key///"));
+  @ParameterizedTest
+  @MethodSource("basenameKeyArguments")
+  void basenameKeyTest(final String expected, final String testString) {
+    assertEquals(expected, NetworkTable.basenameKey(testString));
   }
 
-  public void testNormalizeKeyNoSlash() {
-    assertEquals("a", NetworkTable.normalizeKey("a", false));
-    assertEquals("a", NetworkTable.normalizeKey("///a", false));
-    assertEquals("leading/slash",
-                 NetworkTable.normalizeKey("/leading/slash", false));
-    assertEquals("no/leading/slash",
-                 NetworkTable.normalizeKey("no/leading/slash", false));
-    assertEquals(
-        "what/an/awful/key/",
-        NetworkTable.normalizeKey("//////what////an/awful/////key///", false));
+  private static Stream<Arguments> normalizeKeySlashArguments() {
+    return Stream.of(
+        Arguments.of("/", "///"),
+        Arguments.of("/no/normal/req", "/no/normal/req"),
+        Arguments.of("/no/leading/slash", "no/leading/slash"),
+        Arguments.of("/what/an/awful/key/", "//////what////an/awful/////key///")
+    );
   }
 
-  public void testGetHierarchyEmpty() {
-    List<String> expected = new ArrayList<>();
-    expected.add("/");
-    assertEquals(expected, NetworkTable.getHierarchy(""));
+  @ParameterizedTest
+  @MethodSource("normalizeKeySlashArguments")
+  void normalizeKeySlashTest(final String expected, final String testString) {
+    assertEquals(expected, NetworkTable.normalizeKey(testString));
   }
 
-  public void testGetHierarchyRoot() {
-    List<String> expected = new ArrayList<>();
-    expected.add("/");
-    assertEquals(expected, NetworkTable.getHierarchy("/"));
+  private static Stream<Arguments> normalizeKeyNoSlashArguments() {
+    return Stream.of(
+        Arguments.of("a", "a"),
+        Arguments.of("a", "///a"),
+        Arguments.of("leading/slash", "/leading/slash"),
+        Arguments.of("no/leading/slash", "no/leading/slash"),
+        Arguments.of("what/an/awful/key/", "//////what////an/awful/////key///")
+    );
   }
 
-  public void testGetHierarchyNormal() {
-    List<String> expected = new ArrayList<>();
-    expected.add("/");
-    expected.add("/foo");
-    expected.add("/foo/bar");
-    expected.add("/foo/bar/baz");
-    assertEquals(expected, NetworkTable.getHierarchy("/foo/bar/baz"));
+  @ParameterizedTest
+  @MethodSource("normalizeKeyNoSlashArguments")
+  void normalizeKeyNoSlashTest(final String expected, final String testString) {
+    assertEquals(expected, NetworkTable.normalizeKey(testString, false));
   }
 
-  public void testGetHierarchyTrailingSlash() {
-    List<String> expected = new ArrayList<>();
-    expected.add("/");
-    expected.add("/foo");
-    expected.add("/foo/bar");
-    expected.add("/foo/bar/");
-    assertEquals(expected, NetworkTable.getHierarchy("/foo/bar/"));
+  private static Stream<Arguments> getHierarchyArguments() {
+    return Stream.of(
+        Arguments.of(Arrays.asList("/"), ""),
+        Arguments.of(Arrays.asList("/"), "/"),
+        Arguments.of(Arrays.asList("/", "/foo", "/foo/bar", "/foo/bar/baz"), "/foo/bar/baz"),
+        Arguments.of(Arrays.asList("/", "/foo", "/foo/bar", "/foo/bar/"), "/foo/bar/")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("getHierarchyArguments")
+  void getHierarchyTest(final List<String> expected, final String testString) {
+    assertEquals(expected, NetworkTable.getHierarchy(testString));
   }
 }