Added more edge-cases for unit tests. Removed shutdown timeout

test/dorkboxTest/network/SimpleTest.kt

@@ -15,6 +15,8 @@
  */
 package dorkboxTest.network
 
+import dorkbox.netUtil.IPv4
+import dorkbox.netUtil.IPv6
 import dorkbox.network.Client
 import dorkbox.network.Server
 import dorkbox.network.connection.Connection
@@ -29,9 +31,74 @@ class SimpleTest : BaseTest() {
     var received = AtomicBoolean()
     val sent = AtomicBoolean()
 
+    enum class ConnectType(val ip4: Boolean, val ip6: Boolean, val ipc: Boolean) {
+        IPC(false, false, true),
+        IPC4(true, false, true),
+        IPC6(false, true, true),
+        IPC46(true, true, true),
+        IPC64(true, true, true),
+        IP4(true, false, false),
+        IP6(false, true, false),
+        IP46(true, true, false),
+        IP64(true, true, false)
+    }
+
+
     @Test
     @Throws(SecurityException::class, IOException::class)
-    fun simpleIpv4() {
+    fun simpleIp4() {
+        simple(ConnectType.IP4)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIp6() {
+        simple(ConnectType.IP6)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIp46() {
+        simple(ConnectType.IP46)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIp64() {
+        simple(ConnectType.IP64)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIpc() {
+        simple(ConnectType.IPC)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIpc4Fallback() {
+        simple(ConnectType.IPC4, ConnectType.IPC)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIpc6Fallback() {
+        simple(ConnectType.IPC6 , ConnectType.IPC)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIpc46Fallback() {
+        simple(ConnectType.IPC46 , ConnectType.IPC)
+    }
+
+    @Test
+    @Throws(SecurityException::class, IOException::class)
+    fun simpleIpc64Fallback() {
+        simple(ConnectType.IPC64 , ConnectType.IPC)
+    }
+
+    private fun simple(clientType: ConnectType, serverType: ConnectType = clientType) {
         received.set(false)
         sent.set(false)
 
@@ -39,9 +106,9 @@ class SimpleTest : BaseTest() {
             val configuration = serverConfig()
             configuration.port = 12312
 
-            configuration.enableIPv4 = true
+            configuration.enableIPv4 = serverType.ip4
-            configuration.enableIPv6 = false
+            configuration.enableIPv6 = serverType.ip6
-            configuration.enableIpc = false
+            configuration.enableIpc = serverType.ipc
 
             val server: Server<Connection> = Server(configuration)
             addEndPoint(server)
@@ -62,140 +129,31 @@ class SimpleTest : BaseTest() {
         run {
             val configuration = clientConfig()
             configuration.port = 12312
-            configuration.aeronDirectory = null
 
-            configuration.enableIPv4 = true
+            configuration.enableIPv4 = clientType.ip4
-            configuration.enableIPv6 = false
+            configuration.enableIPv6 = clientType.ip6
-            configuration.enableIpc = false
+            configuration.enableIpc = clientType.ipc
 
 
             val client: Client<Connection> = Client(configuration)
             addEndPoint(client)
 
-
             client.onConnect {
                 sent.set(true)
                 send("client")
             }
 
-            client.connect(LOCALHOST)
+            when (clientType) {
-        }
+                ConnectType.IPC -> client.connect()
-
+                ConnectType.IPC4 -> client.connect(IPv4.LOCALHOST)
-        waitForThreads()
+                ConnectType.IPC6 -> client.connect(IPv6.LOCALHOST)
-
+                ConnectType.IPC46 -> client.connect(IPv4.LOCALHOST)
-        assertTrue(sent.get())
+                ConnectType.IPC64 -> client.connect(IPv6.LOCALHOST)
-        assertTrue(received.get())
+                ConnectType.IP4 -> client.connect(IPv4.LOCALHOST)
-    }
+                ConnectType.IP6 -> client.connect(IPv6.LOCALHOST)
-
+                ConnectType.IP46 -> client.connect(IPv4.LOCALHOST)
-    @Test
+                ConnectType.IP64 -> client.connect(IPv6.LOCALHOST)
-    @Throws(SecurityException::class, IOException::class)
-    fun simpleIpv6() {
-        received.set(false)
-        sent.set(false)
-
-        run {
-            val configuration = serverConfig()
-            configuration.port = 12312
-            configuration.enableIPv4 = false
-            configuration.enableIPv6 = true
-            configuration.enableIpc = false
-
-            val server: Server<Connection> = Server(configuration)
-            addEndPoint(server)
-
-            server.onMessage<String> { message ->
-                if (message != "client") {
-                    Assert.fail()
-                }
-
-                received.set(true)
-                logger.error("Done, stopping endpoints")
-                stopEndPoints()
             }
-
-            server.bind()
-        }
-
-        run {
-            val configuration = clientConfig()
-            configuration.port = 12312
-            configuration.aeronDirectory = null
-
-            configuration.enableIPv4 = false
-            configuration.enableIPv6 = true
-            configuration.enableIpc = false
-
-
-            val client: Client<Connection> = Client(configuration)
-            addEndPoint(client)
-
-
-            client.onConnect {
-                sent.set(true)
-                send("client")
-            }
-
-            client.connect(LOCALHOST)
-        }
-
-        waitForThreads()
-
-        assertTrue(sent.get())
-        assertTrue(received.get())
-    }
-
-    @Test
-    @Throws(SecurityException::class, IOException::class)
-    fun simpleIPC() {
-        received.set(false)
-        sent.set(false)
-
-        run {
-            val configuration = serverConfig()
-            configuration.enableIpc = true
-
-            val server: Server<Connection> = Server(configuration, "server")
-            addEndPoint(server)
-
-            server.onInit {
-                logger.warn { "INIT: server" }
-            }
-
-            server.onConnect {
-                logger.warn { "CONNECT: server" }
-            }
-
-            server.onMessage<String> { message ->
-                if (message != "client") {
-                    Assert.fail()
-                }
-
-                received.set(true)
-                logger.error("Done, stopping endpoints")
-                stopEndPoints()
-            }
-
-            server.bind()
-        }
-
-        run {
-            val configuration = clientConfig()
-            configuration.enableIpc = true
-
-            val client: Client<Connection> = Client(configuration, "client")
-            addEndPoint(client)
-
-            client.onInit {
-                logger.warn { "INIT: client" }
-            }
-
-            client.onConnect {
-                logger.warn { "CONNECT: client" }
-                sent.set(true)
-                send("client")
-            }
-
-            client.connect(LOCALHOST)
         }
 
         waitForThreads()

test/dorkboxTest/network/rmi/RmiSimpleTest.kt

@@ -38,7 +38,6 @@ package dorkboxTest.network.rmi
 import dorkbox.netUtil.IPv4
 import dorkbox.netUtil.IPv6
 import dorkbox.network.Client
-import dorkbox.network.Configuration
 import dorkbox.network.Server
 import dorkbox.network.connection.Connection
 import dorkboxTest.network.BaseTest
@@ -51,33 +50,65 @@ import org.junit.Test
 
 class RmiSimpleTest : BaseTest() {
 
+    enum class ConnectType(val ip4: Boolean, val ip6: Boolean, val ipc: Boolean) {
+        IPC(false, false, true),
+        IPC4(true, false, true),
+        IPC6(false, true, true),
+        IPC46(true, true, true),
+        IPC64(true, true, true),
+        IP4(true, false, false),
+        IP6(false, true, false),
+        IP46(true, true, false),
+        IP64(true, true, false)
+    }
+
+
     @Test
     fun rmiIPv4NetworkGlobal() {
-        rmiGlobal(isIpv4 = true, isIpv6 = false)
+        rmiGlobal(ConnectType.IP4)
     }
 
     @Test
     fun rmiIPv6NetworkGlobal() {
-        rmiGlobal(isIpv4 = true, isIpv6 = false)
+        rmiGlobal(ConnectType.IP6)
     }
 
     @Test
     fun rmiBothIPv4ConnectNetworkGlobal() {
-        rmiGlobal(isIpv4 = true, isIpv6 = true)
+        rmiGlobal(ConnectType.IP46)
     }
 
     @Test
     fun rmiBothIPv6ConnectNetworkGlobal() {
-        rmiGlobal(isIpv4 = true, isIpv6 = true, runIpv4Connect = true)
+        rmiGlobal(ConnectType.IP64)
     }
 
     @Test
     fun rmiIpcNetworkGlobal() {
-        rmiGlobal {
+        rmiGlobal(ConnectType.IPC)
-            enableIpc = true
-        }
     }
 
+    @Test
+    fun rmiIpcNetworkGlobalFallback4() {
+        rmiGlobal(ConnectType.IPC4)
+    }
+
+    @Test
+    fun rmiIpcNetworkGlobalFallback6() {
+        rmiGlobal(ConnectType.IPC6)
+    }
+
+    @Test
+    fun rmiIpcNetworkGlobalFallback46() {
+        rmiGlobal(ConnectType.IPC46)
+    }
+
+    @Test
+    fun rmiIpcNetworkGlobalFallback64() {
+        rmiGlobal(ConnectType.IPC64)
+    }
+
+
 
 
 
@@ -85,50 +116,57 @@ class RmiSimpleTest : BaseTest() {
 
     @Test
     fun rmiIPv4NetworkConnection() {
-        rmi(isIpv4 = true, isIpv6 = false)
+        rmi(ConnectType.IP4)
     }
 
     @Test
     fun rmiIPv6NetworkConnection() {
-        rmi(isIpv4 = false, isIpv6 = true)
+        rmi(ConnectType.IP6)
     }
 
     @Test
     fun rmiBothIPv4ConnectNetworkConnection() {
-        rmi(isIpv4 = true, isIpv6 = true)
+        rmi(ConnectType.IP46)
     }
 
 
     @Test
     fun rmiBothIPv6ConnectNetworkConnection() {
-        rmi(isIpv4 = true, isIpv6 = true, runIpv4Connect = true)
+        rmi(ConnectType.IP64)
     }
 
     @Test
     fun rmiIpcNetworkConnection() {
-        rmi {
+        rmi(ConnectType.IPC)
-            enableIpc = true
-        }
     }
 
-    private fun doConnect(isIpv4: Boolean, isIpv6: Boolean, runIpv4Connect: Boolean, client: Client<Connection>) {
+    @Test
-        when {
+    fun rmiIpcFallback4NetworkConnection() {
-            isIpv4 && isIpv6 && runIpv4Connect -> client.connect(IPv4.LOCALHOST)
+        rmi(ConnectType.IPC4)
-            isIpv4 && isIpv6 && !runIpv4Connect -> client.connect(IPv6.LOCALHOST)
-            isIpv4 -> client.connect(IPv4.LOCALHOST)
-            isIpv6 -> client.connect(IPv6.LOCALHOST)
-            else -> client.connect()
-        }
     }
 
+    @Test
+    fun rmiIpcFallback6NetworkConnection() {
+        rmi(ConnectType.IPC6)
+    }
+
+    @Test
+    fun rmiIpcFallback46NetworkConnection() {
+        rmi(ConnectType.IPC46)
+    }
+
+    @Test
+    fun rmiIpcFallback64NetworkConnection() {
+        rmi(ConnectType.IPC64)
+    }
 
     // GLOBAL rmi stuff cannot CREATE or DELETE (only save/get)
-    private fun rmiGlobal(isIpv4: Boolean = false, isIpv6: Boolean = false, runIpv4Connect: Boolean = true, config: Configuration.() -> Unit = {}) {
+    private fun rmiGlobal(clientType: ConnectType, serverType: ConnectType = clientType) {
         run {
             val configuration = serverConfig()
-            configuration.enableIPv4 = isIpv4
+            configuration.enableIPv4 = serverType.ip4
-            configuration.enableIPv6 = isIpv6
+            configuration.enableIPv6 = serverType.ip6
-            config(configuration)
+            configuration.enableIpc = serverType.ipc
 
             configuration.serialization.rmi.register(TestCow::class.java, TestCowImpl::class.java)
             configuration.serialization.register(MessageWithTestCow::class.java)
@@ -163,7 +201,9 @@ class RmiSimpleTest : BaseTest() {
 
         run {
             val configuration = clientConfig()
-            config(configuration)
+            configuration.enableIPv4 = clientType.ip4
+            configuration.enableIPv6 = clientType.ip6
+            configuration.enableIpc = clientType.ipc
             //            configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java)
 
             val client = Client<Connection>(configuration)
@@ -183,16 +223,26 @@ class RmiSimpleTest : BaseTest() {
                 val id = `object`.id()
                 Assert.assertEquals(4, id)
                 client.logger.error("Finished test for: Client -> Server")
-                stopEndPoints(2000)
+                stopEndPoints()
             }
 
-            doConnect(isIpv4, isIpv6, runIpv4Connect, client)
-
             client.logger.error("Starting test for: Client -> Server")
 
             // this creates a GLOBAL object on the server (instead of a connection specific object)
             runBlocking {
+// fix me!
+            }
 
+            when (clientType) {
+                ConnectType.IPC -> client.connect()
+                ConnectType.IPC4 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IPC6 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IPC46 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IPC64 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IP4 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IP6 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IP46 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IP64 -> client.connect(IPv6.LOCALHOST)
             }
         }
 
@@ -201,12 +251,12 @@ class RmiSimpleTest : BaseTest() {
 
 
 
-    fun rmi(isIpv4: Boolean = false, isIpv6: Boolean = false, runIpv4Connect: Boolean = true, config: Configuration.() -> Unit = {}) {
+    fun rmi(clientType: ConnectType, serverType: ConnectType = clientType) {
         run {
             val configuration = serverConfig()
-            configuration.enableIPv4 = isIpv4
+            configuration.enableIPv4 = serverType.ip4
-            configuration.enableIPv6 = isIpv6
+            configuration.enableIPv6 = serverType.ip6
-            config(configuration)
+            configuration.enableIpc = serverType.ipc
 
             configuration.serialization.rmi.register(TestCow::class.java, TestCowImpl::class.java)
             configuration.serialization.register(MessageWithTestCow::class.java)
@@ -237,7 +287,9 @@ class RmiSimpleTest : BaseTest() {
 
         run {
             val configuration = clientConfig()
-            config(configuration)
+            configuration.enableIPv4 = clientType.ip4
+            configuration.enableIPv6 = clientType.ip6
+            configuration.enableIpc = clientType.ipc
 //            configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java)
 
             val client = Client<Connection>(configuration)
@@ -257,10 +309,20 @@ class RmiSimpleTest : BaseTest() {
                 val id = `object`.id()
                 Assert.assertEquals(123, id)
                 client.logger.error("Finished test for: Client -> Server")
-                stopEndPoints(2000)
+                stopEndPoints()
             }
 
-            doConnect(isIpv4, isIpv6, runIpv4Connect, client)
+            when (clientType) {
+                ConnectType.IPC -> client.connect()
+                ConnectType.IPC4 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IPC6 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IPC46 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IPC64 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IP4 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IP6 -> client.connect(IPv6.LOCALHOST)
+                ConnectType.IP46 -> client.connect(IPv4.LOCALHOST)
+                ConnectType.IP64 -> client.connect(IPv6.LOCALHOST)
+            }
         }
 
         waitForThreads()