dorkbox/Network
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

WIP unit tests. Renamed package, so stacktrace cleanup works correctly (it's based on package name)

Browse Source
This commit is contained in:
nathan 2020-08-12 23:38:56 +02:00
parent 10e581a21c
commit 994fa8d196
18 changed files with 400 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
test/dorkbox/network/AeronClient.kt → test/dorkboxTest/network/AeronClient.kt
View File

@ -1,4 +1,4 @@
package dorkbox.network package dorkboxTest.network
import ch.qos.logback.classic.Level import ch.qos.logback.classic.Level
import ch.qos.logback.classic.Logger import ch.qos.logback.classic.Logger
@ -6,6 +6,8 @@ import ch.qos.logback.classic.encoder.PatternLayoutEncoder
import ch.qos.logback.classic.joran.JoranConfigurator import ch.qos.logback.classic.joran.JoranConfigurator
import ch.qos.logback.classic.spi.ILoggingEvent import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.ConsoleAppender import ch.qos.logback.core.ConsoleAppender
import dorkbox.network.Client
import dorkbox.network.Configuration
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory
@ -91,6 +93,9 @@ object AeronClient {
configuration.publicationPort = 2001 configuration.publicationPort = 2001
val client = Client<Connection>(configuration) val client = Client<Connection>(configuration)
// client.filter(IpSubnetFilterRule(IPv4.LOCALHOST, 32, IpFilterRuleType.ACCEPT))
client.filter { connection -> client.filter { connection ->
println("should this connection be allowed?") println("should this connection be allowed?")
true true
@ -115,8 +120,8 @@ object AeronClient {
} }
runBlocking { runBlocking {
// client.connect("127.0.0.1") // UDP connection via loopback client.connect("127.0.0.1") // UDP connection via loopback
client.connect() // IPC connection // client.connect() // IPC connection
} }
@ -128,7 +133,7 @@ object AeronClient {
// send - IPC/local // send - IPC/local
runBlocking { runBlocking {
while (!client.isShutdown()) { while (!client.isShutdown()) {
client.send("ECHO " + java.lang.Long.toUnsignedString(client.secureRandom.nextLong(), 16)) client.send("ECHO " + java.lang.Long.toUnsignedString(client.crypto.secureRandom.nextLong(), 16))
} }
} }

4
test/dorkbox/network/AeronServer.kt → test/dorkboxTest/network/AeronServer.kt
View File

@ -1,4 +1,4 @@
package dorkbox.network package dorkboxTest.network
import ch.qos.logback.classic.Level import ch.qos.logback.classic.Level
import ch.qos.logback.classic.Logger import ch.qos.logback.classic.Logger
@ -6,6 +6,8 @@ import ch.qos.logback.classic.encoder.PatternLayoutEncoder
import ch.qos.logback.classic.joran.JoranConfigurator import ch.qos.logback.classic.joran.JoranConfigurator
import ch.qos.logback.classic.spi.ILoggingEvent import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.ConsoleAppender import ch.qos.logback.core.ConsoleAppender
import dorkbox.network.Server
import dorkbox.network.ServerConfiguration
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory

8
test/dorkbox/network/BaseTest.kt → test/dorkboxTest/network/BaseTest.kt
View File

@ -17,7 +17,7 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network package dorkboxTest.network
import ch.qos.logback.classic.Level import ch.qos.logback.classic.Level
import ch.qos.logback.classic.Logger import ch.qos.logback.classic.Logger
@ -25,8 +25,12 @@ import ch.qos.logback.classic.encoder.PatternLayoutEncoder
import ch.qos.logback.classic.joran.JoranConfigurator import ch.qos.logback.classic.joran.JoranConfigurator
import ch.qos.logback.classic.spi.ILoggingEvent import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.ConsoleAppender import ch.qos.logback.core.ConsoleAppender
import dorkbox.network.Client
import dorkbox.network.Configuration
import dorkbox.network.Server
import dorkbox.network.ServerConfiguration
import dorkbox.network.connection.EndPoint import dorkbox.network.connection.EndPoint
import dorkbox.util.OS import dorkbox.os.OS
import dorkbox.util.entropy.Entropy import dorkbox.util.entropy.Entropy
import dorkbox.util.entropy.SimpleEntropy import dorkbox.util.entropy.SimpleEntropy
import dorkbox.util.exceptions.InitializationException import dorkbox.util.exceptions.InitializationException

50
test/dorkbox/network/ListenerTest.kt → test/dorkboxTest/network/ListenerTest.kt
View File

@ -17,9 +17,11 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network package dorkboxTest.network
import dorkbox.network.connection.ConnectionImpl import dorkbox.network.Client
import dorkbox.network.Server
import dorkbox.network.connection.Connection
import dorkbox.network.connection.EndPoint import dorkbox.network.connection.EndPoint
import dorkbox.network.connection.MediaDriverConnection import dorkbox.network.connection.MediaDriverConnection
import dorkbox.util.exceptions.InitializationException import dorkbox.util.exceptions.InitializationException
@ -38,24 +40,25 @@ class ListenerTest : BaseTest() {
var checkFail1 = AtomicBoolean(false) var checkFail1 = AtomicBoolean(false)
var checkFail2 = AtomicBoolean(false) var checkFail2 = AtomicBoolean(false)
var check1 = AtomicBoolean(false) var overrideCheck = AtomicBoolean(false)
var check2 = AtomicBoolean(false) var serverOnMessage = AtomicBoolean(false)
var check3 = AtomicBoolean(false) var serverConnect = AtomicBoolean(false)
var check4 = AtomicBoolean(false) var serverDisconnect = AtomicBoolean(false)
var check5 = AtomicBoolean(false) var clientConnect = AtomicBoolean(false)
var check6 = AtomicBoolean(false) var clientDisconnect = AtomicBoolean(false)
// quick and dirty test to also test connection sub-classing // quick and dirty test to also test connection sub-classing
internal open inner class TestConnectionA(endPointConnection: EndPoint<TestConnectionA>, driverConnection: MediaDriverConnection) : ConnectionImpl(endPointConnection, driverConnection) { internal open inner class TestConnectionA(endPointConnection: EndPoint<TestConnectionA>, driverConnection: MediaDriverConnection) : Connection(endPointConnection, driverConnection) {
open fun check() { open fun check() {
check1.set(true) overrideCheck.set(true)
} }
} }
@Test @Test
@Throws(SecurityException::class, InitializationException::class, IOException::class, InterruptedException::class) @Throws(SecurityException::class, InitializationException::class, IOException::class, InterruptedException::class)
fun listener() { fun listener() {
val server: Server<TestConnectionA> = object : Server<TestConnectionA>(serverConfig()) { val server: Server<TestConnectionA> = object : Server<TestConnectionA>(
serverConfig()) {
override fun newConnection(endPoint: EndPoint<TestConnectionA>, mediaDriverConnection: MediaDriverConnection): TestConnectionA { override fun newConnection(endPoint: EndPoint<TestConnectionA>, mediaDriverConnection: MediaDriverConnection): TestConnectionA {
return TestConnectionA(endPoint, mediaDriverConnection) return TestConnectionA(endPoint, mediaDriverConnection)
} }
@ -72,17 +75,17 @@ class ListenerTest : BaseTest() {
// generic listener // generic listener
server.onMessage<Any> { _, _ -> server.onMessage<Any> { _, _ ->
// should be called! // should be called!
check2.set(true) serverOnMessage.set(true)
} }
// standard connect check // standard connect check
server.onConnect { server.onConnect {
check3.set(true) serverConnect.set(true)
} }
// standard listener disconnect check // standard listener disconnect check
server.onDisconnect { server.onDisconnect {
check4.set(true) serverDisconnect.set(true)
} }
@ -92,7 +95,8 @@ class ListenerTest : BaseTest() {
// ---- // ----
val client: Client<TestConnectionA> = object : Client<TestConnectionA>(clientConfig()) { val client: Client<TestConnectionA> = object : Client<TestConnectionA>(
clientConfig()) {
override fun newConnection(endPoint: EndPoint<TestConnectionA>, mediaDriverConnection: MediaDriverConnection): TestConnectionA { override fun newConnection(endPoint: EndPoint<TestConnectionA>, mediaDriverConnection: MediaDriverConnection): TestConnectionA {
return TestConnectionA(endPoint, mediaDriverConnection) return TestConnectionA(endPoint, mediaDriverConnection)
} }
@ -121,13 +125,13 @@ class ListenerTest : BaseTest() {
// standard connect check // standard connect check
client.onConnect { client.onConnect {
check5.set(true) clientConnect.set(true)
} }
// standard listener disconnect check // standard listener disconnect check
client.onDisconnect { client.onDisconnect {
check6.set(true) clientDisconnect.set(true)
} }
@ -139,12 +143,12 @@ class ListenerTest : BaseTest() {
// -1 BECAUSE we are `getAndIncrement` for each check earlier // -1 BECAUSE we are `getAndIncrement` for each check earlier
Assert.assertEquals(limit.toLong(), count.get() - 1.toLong()) Assert.assertEquals(limit.toLong(), count.get() - 1.toLong())
Assert.assertTrue(check1.get()) Assert.assertTrue(overrideCheck.get())
Assert.assertTrue(check2.get()) Assert.assertTrue(serverOnMessage.get())
Assert.assertTrue(check3.get()) Assert.assertTrue(serverConnect.get())
Assert.assertTrue(check4.get()) Assert.assertTrue(serverDisconnect.get())
Assert.assertTrue(check5.get()) Assert.assertTrue(clientConnect.get())
Assert.assertTrue(check6.get()) Assert.assertTrue(clientDisconnect.get())
Assert.assertFalse(checkFail1.get()) Assert.assertFalse(checkFail1.get())
Assert.assertFalse(checkFail2.get()) Assert.assertFalse(checkFail2.get())

4
test/dorkbox/network/MultipleServerTest.kt → test/dorkboxTest/network/MultipleServerTest.kt
View File

@ -17,8 +17,10 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network package dorkboxTest.network
import dorkbox.network.Client
import dorkbox.network.Server
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking

4
test/dorkbox/network/PingPongTest.kt → test/dorkboxTest/network/PingPongTest.kt
View File

@ -17,8 +17,10 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network package dorkboxTest.network
import dorkbox.network.Client
import dorkbox.network.Server
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import dorkbox.util.serialization.SerializationManager import dorkbox.util.serialization.SerializationManager

170
test/dorkbox/network/kryo/InputOutputByteBufTest.java → test/dorkboxTest/network/kryo/InputOutputByteBufTest.java
View File

@ -17,10 +17,8 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
package dorkbox.network.kryo; package dorkboxTest.network.kryo;
import static dorkbox.network.kryo.KryoAssert.assertDoubleEquals;
import static dorkbox.network.kryo.KryoAssert.assertFloatEquals;
import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertFalse;
@ -716,47 +714,47 @@ public class InputOutputByteBufTest extends KryoTestCase {
assertEquals(5, write.writeVarFloat(-8192, 1000, true)); assertEquals(5, write.writeVarFloat(-8192, 1000, true));
AeronInput read = new AeronInput(write.toBytes()); AeronInput read = new AeronInput(write.toBytes());
assertFloatEquals(read.readFloat(), 0f); KryoAssert.assertFloatEquals(read.readFloat(), 0f);
assertFloatEquals(read.readFloat(), 63f); KryoAssert.assertFloatEquals(read.readFloat(), 63f);
assertFloatEquals(read.readFloat(), 64f); KryoAssert.assertFloatEquals(read.readFloat(), 64f);
assertFloatEquals(read.readFloat(), 127f); KryoAssert.assertFloatEquals(read.readFloat(), 127f);
assertFloatEquals(read.readFloat(), 128f); KryoAssert.assertFloatEquals(read.readFloat(), 128f);
assertFloatEquals(read.readFloat(), 8192f); KryoAssert.assertFloatEquals(read.readFloat(), 8192f);
assertFloatEquals(read.readFloat(), 16384f); KryoAssert.assertFloatEquals(read.readFloat(), 16384f);
assertFloatEquals(read.readFloat(), 32767f); KryoAssert.assertFloatEquals(read.readFloat(), 32767f);
assertFloatEquals(read.readFloat(), -63f); KryoAssert.assertFloatEquals(read.readFloat(), -63f);
assertFloatEquals(read.readFloat(), -64f); KryoAssert.assertFloatEquals(read.readFloat(), -64f);
assertFloatEquals(read.readFloat(), -127f); KryoAssert.assertFloatEquals(read.readFloat(), -127f);
assertFloatEquals(read.readFloat(), -128f); KryoAssert.assertFloatEquals(read.readFloat(), -128f);
assertFloatEquals(read.readFloat(), -8192f); KryoAssert.assertFloatEquals(read.readFloat(), -8192f);
assertFloatEquals(read.readFloat(), -16384f); KryoAssert.assertFloatEquals(read.readFloat(), -16384f);
assertFloatEquals(read.readFloat(), -32768f); KryoAssert.assertFloatEquals(read.readFloat(), -32768f);
assertFloatEquals(read.readVarFloat(1000, true), 0f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 0f);
assertFloatEquals(read.readVarFloat(1000, false), 0f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 0f);
assertFloatEquals(read.readVarFloat(1000, true), 63f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 63f);
assertFloatEquals(read.readVarFloat(1000, false), 63f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 63f);
assertFloatEquals(read.readVarFloat(1000, true), 64f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 64f);
assertFloatEquals(read.readVarFloat(1000, false), 64f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 64f);
assertFloatEquals(read.readVarFloat(1000, true), 127f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 127f);
assertFloatEquals(read.readVarFloat(1000, false), 127f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 127f);
assertFloatEquals(read.readVarFloat(1000, true), 128f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 128f);
assertFloatEquals(read.readVarFloat(1000, false), 128f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 128f);
assertFloatEquals(read.readVarFloat(1000, true), 8191f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 8191f);
assertFloatEquals(read.readVarFloat(1000, false), 8191f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 8191f);
assertFloatEquals(read.readVarFloat(1000, true), 8192f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 8192f);
assertFloatEquals(read.readVarFloat(1000, false), 8192f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 8192f);
assertFloatEquals(read.readVarFloat(1000, true), 16383f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 16383f);
assertFloatEquals(read.readVarFloat(1000, false), 16383f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 16383f);
assertFloatEquals(read.readVarFloat(1000, true), 16384f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 16384f);
assertFloatEquals(read.readVarFloat(1000, false), 16384f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 16384f);
assertFloatEquals(read.readVarFloat(1000, true), 32767f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), 32767f);
assertFloatEquals(read.readVarFloat(1000, false), 32767f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), 32767f);
assertFloatEquals(read.readVarFloat(1000, false), -64f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -64f);
assertFloatEquals(read.readVarFloat(1000, true), -64f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -64f);
assertFloatEquals(read.readVarFloat(1000, false), -65f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -65f);
assertFloatEquals(read.readVarFloat(1000, true), -65f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -65f);
assertFloatEquals(read.readVarFloat(1000, false), -8192f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, false), -8192f);
assertFloatEquals(read.readVarFloat(1000, true), -8192f); KryoAssert.assertFloatEquals(read.readVarFloat(1000, true), -8192f);
} }
@Test @Test
@ -810,48 +808,48 @@ public class InputOutputByteBufTest extends KryoTestCase {
write.writeDouble(1.23456d); write.writeDouble(1.23456d);
AeronInput read = new AeronInput(write.toBytes()); AeronInput read = new AeronInput(write.toBytes());
assertDoubleEquals(read.readDouble(), 0d); KryoAssert.assertDoubleEquals(read.readDouble(), 0d);
assertDoubleEquals(read.readDouble(), 63d); KryoAssert.assertDoubleEquals(read.readDouble(), 63d);
assertDoubleEquals(read.readDouble(), 64d); KryoAssert.assertDoubleEquals(read.readDouble(), 64d);
assertDoubleEquals(read.readDouble(), 127d); KryoAssert.assertDoubleEquals(read.readDouble(), 127d);
assertDoubleEquals(read.readDouble(), 128d); KryoAssert.assertDoubleEquals(read.readDouble(), 128d);
assertDoubleEquals(read.readDouble(), 8192d); KryoAssert.assertDoubleEquals(read.readDouble(), 8192d);
assertDoubleEquals(read.readDouble(), 16384d); KryoAssert.assertDoubleEquals(read.readDouble(), 16384d);
assertDoubleEquals(read.readDouble(), 32767d); KryoAssert.assertDoubleEquals(read.readDouble(), 32767d);
assertDoubleEquals(read.readDouble(), -63d); KryoAssert.assertDoubleEquals(read.readDouble(), -63d);
assertDoubleEquals(read.readDouble(), -64d); KryoAssert.assertDoubleEquals(read.readDouble(), -64d);
assertDoubleEquals(read.readDouble(), -127d); KryoAssert.assertDoubleEquals(read.readDouble(), -127d);
assertDoubleEquals(read.readDouble(), -128d); KryoAssert.assertDoubleEquals(read.readDouble(), -128d);
assertDoubleEquals(read.readDouble(), -8192d); KryoAssert.assertDoubleEquals(read.readDouble(), -8192d);
assertDoubleEquals(read.readDouble(), -16384d); KryoAssert.assertDoubleEquals(read.readDouble(), -16384d);
assertDoubleEquals(read.readDouble(), -32768d); KryoAssert.assertDoubleEquals(read.readDouble(), -32768d);
assertDoubleEquals(read.readVarDouble(1000, true), 0d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 0d);
assertDoubleEquals(read.readVarDouble(1000, false), 0d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 0d);
assertDoubleEquals(read.readVarDouble(1000, true), 63d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 63d);
assertDoubleEquals(read.readVarDouble(1000, false), 63d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 63d);
assertDoubleEquals(read.readVarDouble(1000, true), 64d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 64d);
assertDoubleEquals(read.readVarDouble(1000, false), 64d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 64d);
assertDoubleEquals(read.readVarDouble(1000, true), 127d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 127d);
assertDoubleEquals(read.readVarDouble(1000, false), 127d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 127d);
assertDoubleEquals(read.readVarDouble(1000, true), 128d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 128d);
assertDoubleEquals(read.readVarDouble(1000, false), 128d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 128d);
assertDoubleEquals(read.readVarDouble(1000, true), 8191d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 8191d);
assertDoubleEquals(read.readVarDouble(1000, false), 8191d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 8191d);
assertDoubleEquals(read.readVarDouble(1000, true), 8192d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 8192d);
assertDoubleEquals(read.readVarDouble(1000, false), 8192d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 8192d);
assertDoubleEquals(read.readVarDouble(1000, true), 16383d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 16383d);
assertDoubleEquals(read.readVarDouble(1000, false), 16383d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 16383d);
assertDoubleEquals(read.readVarDouble(1000, true), 16384d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 16384d);
assertDoubleEquals(read.readVarDouble(1000, false), 16384d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 16384d);
assertDoubleEquals(read.readVarDouble(1000, true), 32767d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), 32767d);
assertDoubleEquals(read.readVarDouble(1000, false), 32767d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), 32767d);
assertDoubleEquals(read.readVarDouble(1000, false), -64d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -64d);
assertDoubleEquals(read.readVarDouble(1000, true), -64d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -64d);
assertDoubleEquals(read.readVarDouble(1000, false), -65d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -65d);
assertDoubleEquals(read.readVarDouble(1000, true), -65d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -65d);
assertDoubleEquals(read.readVarDouble(1000, false), -8192d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, false), -8192d);
assertDoubleEquals(read.readVarDouble(1000, true), -8192d); KryoAssert.assertDoubleEquals(read.readVarDouble(1000, true), -8192d);
assertDoubleEquals(1.23456d, read.readDouble()); KryoAssert.assertDoubleEquals(1.23456d, read.readDouble());
} }
@Test @Test

4
test/dorkbox/network/kryo/KryoAssert.java → test/dorkboxTest/network/kryo/KryoAssert.java
View File

@ -1,6 +1,6 @@
package dorkbox.network.kryo; package dorkboxTest.network.kryo;
import static org.junit.Assert.*; import static org.junit.Assert.assertEquals;
/** /**
* Junit Assert wrapper methods class * Junit Assert wrapper methods class

62
test/dorkbox/network/kryo/KryoTestCase.java → test/dorkboxTest/network/kryo/KryoTestCase.java
View File

@ -17,7 +17,7 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
package dorkbox.network.kryo; package dorkboxTest.network.kryo;
import static com.esotericsoftware.minlog.Log.WARN; import static com.esotericsoftware.minlog.Log.WARN;
import static com.esotericsoftware.minlog.Log.warn; import static com.esotericsoftware.minlog.Log.warn;
@ -79,23 +79,28 @@ abstract public class KryoTestCase {
/** @param length Pass Integer.MIN_VALUE to disable checking the length. */ /** @param length Pass Integer.MIN_VALUE to disable checking the length. */
public <T> T roundTrip (int length, T object1) { public <T> T roundTrip (int length, T object1) {
T object2 = roundTripWithBufferFactory(length, object1, new BufferFactory() { T object2 = roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) { @Override
public Output createOutput (OutputStream os) {
return new Output(os); return new Output(os);
} }
public Output createOutput (OutputStream os, int size) { @Override
public Output createOutput (OutputStream os, int size) {
return new Output(os, size); return new Output(os, size);
} }
public Output createOutput (int size, int limit) { @Override
public Output createOutput (int size, int limit) {
return new Output(size, limit); return new Output(size, limit);
} }
public Input createInput (InputStream os, int size) { @Override
public Input createInput (InputStream os, int size) {
return new Input(os, size); return new Input(os, size);
} }
public Input createInput (byte[] buffer) { @Override
public Input createInput (byte[] buffer) {
return new Input(buffer); return new Input(buffer);
} }
}); });
@ -103,23 +108,28 @@ abstract public class KryoTestCase {
if (debug) return object2; if (debug) return object2;
roundTripWithBufferFactory(length, object1, new BufferFactory() { roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) { @Override
public Output createOutput (OutputStream os) {
return new ByteBufferOutput(os); return new ByteBufferOutput(os);
} }
public Output createOutput (OutputStream os, int size) { @Override
public Output createOutput (OutputStream os, int size) {
return new ByteBufferOutput(os, size); return new ByteBufferOutput(os, size);
} }
public Output createOutput (int size, int limit) { @Override
public Output createOutput (int size, int limit) {
return new ByteBufferOutput(size, limit); return new ByteBufferOutput(size, limit);
} }
public Input createInput (InputStream os, int size) { @Override
public Input createInput (InputStream os, int size) {
return new ByteBufferInput(os, size); return new ByteBufferInput(os, size);
} }
public Input createInput (byte[] buffer) { @Override
public Input createInput (byte[] buffer) {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length); ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
byteBuffer.put(buffer).flip(); byteBuffer.put(buffer).flip();
return new ByteBufferInput(byteBuffer); return new ByteBufferInput(byteBuffer);
@ -127,45 +137,55 @@ abstract public class KryoTestCase {
}); });
roundTripWithBufferFactory(length, object1, new BufferFactory() { roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) { @Override
public Output createOutput (OutputStream os) {
return new UnsafeOutput(os); return new UnsafeOutput(os);
} }
public Output createOutput (OutputStream os, int size) { @Override
public Output createOutput (OutputStream os, int size) {
return new UnsafeOutput(os, size); return new UnsafeOutput(os, size);
} }
public Output createOutput (int size, int limit) { @Override
public Output createOutput (int size, int limit) {
return new UnsafeOutput(size, limit); return new UnsafeOutput(size, limit);
} }
public Input createInput (InputStream os, int size) { @Override
public Input createInput (InputStream os, int size) {
return new UnsafeInput(os, size); return new UnsafeInput(os, size);
} }
public Input createInput (byte[] buffer) { @Override
public Input createInput (byte[] buffer) {
return new UnsafeInput(buffer); return new UnsafeInput(buffer);
} }
}); });
roundTripWithBufferFactory(length, object1, new BufferFactory() { roundTripWithBufferFactory(length, object1, new BufferFactory() {
public Output createOutput (OutputStream os) { @Override
public Output createOutput (OutputStream os) {
return new UnsafeByteBufferOutput(os); return new UnsafeByteBufferOutput(os);
} }
public Output createOutput (OutputStream os, int size) { @Override
public Output createOutput (OutputStream os, int size) {
return new UnsafeByteBufferOutput(os, size); return new UnsafeByteBufferOutput(os, size);
} }
public Output createOutput (int size, int limit) { @Override
public Output createOutput (int size, int limit) {
return new UnsafeByteBufferOutput(size, limit); return new UnsafeByteBufferOutput(size, limit);
} }
public Input createInput (InputStream os, int size) { @Override
public Input createInput (InputStream os, int size) {
return new UnsafeByteBufferInput(os, size); return new UnsafeByteBufferInput(os, size);
} }
public Input createInput (byte[] buffer) { @Override
public Input createInput (byte[] buffer) {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length); ByteBuffer byteBuffer = ByteBuffer.allocateDirect(buffer.length);
byteBuffer.put(buffer).flip(); byteBuffer.put(buffer).flip();
return new UnsafeByteBufferInput(byteBuffer); return new UnsafeByteBufferInput(byteBuffer);

196
test/dorkboxTest/network/rmi/RmiGlobalTest.kt Normal file
View File

@ -0,0 +1,196 @@
/*
* Copyright 2016 dorkbox, llc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright (c) 2008, Nathan Sweet
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
* - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package dorkboxTest.network.rmi
import dorkbox.network.Client
import dorkbox.network.Configuration
import dorkbox.network.Server
import dorkbox.network.connection.Connection
import dorkbox.util.exceptions.SecurityException
import dorkboxTest.network.BaseTest
import dorkboxTest.network.rmi.classes.MessageWithTestCow
import dorkboxTest.network.rmi.classes.TestCow
import kotlinx.coroutines.runBlocking
import org.junit.Assert
import org.junit.Test
import java.io.IOException
class RmiGlobalTest : BaseTest() {
companion object {
private const val CLIENT_GLOBAL_OBJECT_ID = 123
private const val SERVER_GLOBAL_OBJECT_ID = 2453
}
@Test
@Throws(SecurityException::class, IOException::class)
fun rmiNetwork() {
rmi()
}
@Test
@Throws(SecurityException::class, IOException::class)
fun rmiLocal() {
// rmi(object : Config() {
// fun apply(configuration: Configuration) {
// configuration.localChannelName = EndPoint.LOCAL_CHANNEL
// }
// })
}
fun rmi(config: (Configuration) -> Unit = {}) {
run {
val configuration = serverConfig()
config(configuration)
RmiTest.register(configuration.serialization)
// NOTICE: none of the super classes/interfaces are registered!
configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java)
val server = Server<Connection>(configuration)
addEndPoint(server)
// register this object as a global object that the client will get
server.saveGlobalObject(TestCowImpl(SERVER_GLOBAL_OBJECT_ID), SERVER_GLOBAL_OBJECT_ID)
server.onConnect { connection ->
val remoteObject = connection.getObject<TestCow>(CLIENT_GLOBAL_OBJECT_ID)
System.err.println("Running test for: Server (LOCAL) -> Client (REMOTE)")
RmiTest.runTests(connection, remoteObject, CLIENT_GLOBAL_OBJECT_ID)
System.err.println("Done with test for: Server (LOCAL) -> Client (REMOTE)")
}
server.onMessage<MessageWithTestCow> { connection, message ->
System.err.println("Received finish signal for test for: Client (LOCAL) -> Server (REMOTE)")
val `object`: TestCow = message.testCow
val id: Int = `object`.id()
Assert.assertEquals(SERVER_GLOBAL_OBJECT_ID.toLong(), id.toLong())
System.err.println("Finished test for: Client (LOCAL) -> Server (REMOTE)")
stopEndPoints(2000)
}
server.bind(false)
}
run {
val configuration = clientConfig()
config(configuration)
RmiTest.register(configuration.serialization)
// NOTICE: none of the super classes/interfaces are registered!
configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java)
val client = Client<Connection>(configuration)
addEndPoint(client)
// register this object as a global object that the server will get
client.saveObject(TestCowImpl(CLIENT_GLOBAL_OBJECT_ID), CLIENT_GLOBAL_OBJECT_ID)
client.onMessage<MessageWithTestCow> { connection, message ->
System.err.println("Received finish signal for test for: Server (LOCAL) -> Client (REMOTE)")
// this TestCow object should be the implementation, not the proxy.
val `object`: TestCow = message.testCow
val id: Int = `object`.id()
Assert.assertEquals(CLIENT_GLOBAL_OBJECT_ID.toLong(), id.toLong())
System.err.println("Finished test for: Server (LOCAL) -> Client (REMOTE)")
// normally this is in the 'connected', but we do it here, so that it's more linear and easier to debug
val remoteCow = connection.getGlobalObject<TestCow>(SERVER_GLOBAL_OBJECT_ID)
System.err.println("Running test for: Client (LOCAL) -> Server (REMOTE)")
RmiTest.runTests(connection, remoteCow, SERVER_GLOBAL_OBJECT_ID)
System.err.println("Done with test for: Client (LOCAL) -> Server (REMOTE)")
}
runBlocking {
client.connect(LOOPBACK)
}
}
waitForThreads(99999999)
}
private open class ConnectionAware {
var connection: Connection? = null
}
private class TestCowImpl(private val id: Int) : ConnectionAware(),
TestCow {
var value = System.currentTimeMillis()
var moos = 0
override fun throwException() {
throw UnsupportedOperationException("Why would I do that?")
}
override fun moo() {
moos++
println("Moo!")
}
override fun moo(value: String) {
moos += 2
println("Moo: $value")
}
override fun moo(value: String, delay: Long) {
moos += 4
println("Moo: $value ($delay)")
try {
Thread.sleep(delay)
} catch (e: InterruptedException) {
e.printStackTrace()
}
}
override fun id(): Int {
return id
}
override fun slow(): Float {
println("Slowdown!!")
try {
Thread.sleep(2000)
} catch (e: InterruptedException) {
e.printStackTrace()
}
return 123.0f
}
}
}

5
test/dorkbox/network/rmi/RmiSendObjectOverrideMethodTest.kt → test/dorkboxTest/network/rmi/RmiSendObjectOverrideMethodTest.kt
View File

@ -13,14 +13,15 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi package dorkboxTest.network.rmi
import dorkbox.network.BaseTest
import dorkbox.network.Client import dorkbox.network.Client
import dorkbox.network.Configuration import dorkbox.network.Configuration
import dorkbox.network.Server import dorkbox.network.Server
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import dorkbox.network.rmi.Rmi
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import dorkboxTest.network.BaseTest
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test

5
test/dorkbox/network/rmi/RmiSendObjectTest.kt → test/dorkboxTest/network/rmi/RmiSendObjectTest.kt
View File

@ -32,14 +32,15 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network.rmi package dorkboxTest.network.rmi
import dorkbox.network.BaseTest
import dorkbox.network.Client import dorkbox.network.Client
import dorkbox.network.Configuration import dorkbox.network.Configuration
import dorkbox.network.Server import dorkbox.network.Server
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import dorkbox.network.rmi.Rmi
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import dorkboxTest.network.BaseTest
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test

51
test/dorkbox/network/rmi/RmiTest.kt → test/dorkboxTest/network/rmi/RmiTest.kt
View File

@ -32,15 +32,20 @@
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package dorkbox.network.rmi package dorkboxTest.network.rmi
import dorkbox.network.* import dorkbox.network.Client
import dorkbox.network.Configuration
import dorkbox.network.Server
import dorkbox.network.ServerConfiguration
import dorkbox.network.connection.Connection import dorkbox.network.connection.Connection
import dorkbox.network.rmi.classes.MessageWithTestCow import dorkbox.network.rmi.RemoteObject
import dorkbox.network.rmi.classes.TestCow
import dorkbox.network.rmi.classes.TestCowImpl
import dorkbox.network.serialization.NetworkSerializationManager import dorkbox.network.serialization.NetworkSerializationManager
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import dorkboxTest.network.BaseTest
import dorkboxTest.network.rmi.classes.MessageWithTestCow
import dorkboxTest.network.rmi.classes.TestCow
import dorkboxTest.network.rmi.classes.TestCowImpl
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test
@ -76,17 +81,7 @@ class RmiTest : BaseTest() {
try { try {
test.throwException() test.throwException()
} catch (ex: UnsupportedOperationException) { } catch (ex: UnsupportedOperationException) {
System.err.println("\tExpected exception (exception log should ONLY be on the server).") System.err.println("\tExpected exception (exception log should ONLY be on the object impl side).")
caught = true
}
Assert.assertTrue(caught)
// can ONLY wait for responses if we are ASYNC!
caught = false
try {
remoteObject.waitForLastResponse()
} catch (ex: IllegalStateException) {
caught = true caught = true
} }
Assert.assertTrue(caught) Assert.assertTrue(caught)
@ -113,32 +108,13 @@ class RmiTest : BaseTest() {
try { try {
test.throwException() test.throwException()
} catch (ex: IllegalStateException) { } catch (ex: IllegalStateException) {
System.err.println("\tExpected exception (exception log should ONLY be on the object impl side).")
caught = true caught = true
} }
// exceptions are not caught when async = true! // exceptions are not caught when async = true!
Assert.assertFalse(caught) Assert.assertFalse(caught)
// now enable us to wait for responses
// can ONLY wait for responses if we are ASYNC + enabled waiting!!
remoteObject.enableWaitingForResponse(true)
test.id()
// wait for the response to id()
Assert.assertEquals(remoteObjectID, remoteObject.waitForLastResponse())
// wait for the response to id()
Assert.assertEquals(0, test.id().toLong())
val responseId = remoteObject.lastResponseId
Assert.assertEquals(remoteObjectID, remoteObject.waitForResponse(responseId))
// Non-blocking call that errors out
test.throwException()
Assert.assertEquals(remoteObject.waitForLastResponse()?.javaClass, UnsupportedOperationException::class.java)
// Call will time out if non-blocking isn't working properly // Call will time out if non-blocking isn't working properly
test.moo("Mooooooooo", 4000) test.moo("Mooooooooo", 4000)
@ -241,12 +217,11 @@ class RmiTest : BaseTest() {
// for Server -> Client RMI // for Server -> Client RMI
configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java) configuration.serialization.registerRmi(TestCow::class.java, TestCowImpl::class.java)
val client = Client<Connection>(configuration) val client = Client<Connection>(configuration)
addEndPoint(client) addEndPoint(client)
client.onConnect { connection -> client.onConnect { connection ->
System.err.println("Starting test for: Client -> Server")
connection.createObject<TestCow> { remoteObject -> connection.createObject<TestCow> { remoteObject ->
System.err.println("Running test for: Client -> Server") System.err.println("Running test for: Client -> Server")
runTests(connection, remoteObject, 1) runTests(connection, remoteObject, 1)

2
test/dorkbox/network/rmi/classes/MessageWithTestCow.kt → test/dorkboxTest/network/rmi/classes/MessageWithTestCow.kt
View File

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi.classes package dorkboxTest.network.rmi.classes
class MessageWithTestCow(val testCow: TestCow) { class MessageWithTestCow(val testCow: TestCow) {
var number = 0 var number = 0

2
test/dorkbox/network/rmi/classes/TestCow.kt → test/dorkboxTest/network/rmi/classes/TestCow.kt
View File

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi.classes package dorkboxTest.network.rmi.classes
/** /**
* *

2
test/dorkbox/network/rmi/classes/TestCowBase.kt → test/dorkboxTest/network/rmi/classes/TestCowBase.kt
View File

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi.classes package dorkboxTest.network.rmi.classes
/** /**
* This is a different interface so we can also test CachedMethod operations * This is a different interface so we can also test CachedMethod operations

2
test/dorkbox/network/rmi/classes/TestCowBaseImpl.kt → test/dorkboxTest/network/rmi/classes/TestCowBaseImpl.kt
View File

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi.classes package dorkboxTest.network.rmi.classes
open class TestCowBaseImpl : TestCowBase { open class TestCowBaseImpl : TestCowBase {
override fun throwException() { override fun throwException() {

5
test/dorkbox/network/rmi/classes/TestCowImpl.kt → test/dorkboxTest/network/rmi/classes/TestCowImpl.kt
View File

@ -12,11 +12,12 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package dorkbox.network.rmi.classes package dorkboxTest.network.rmi.classes
import java.util.concurrent.atomic.AtomicInteger import java.util.concurrent.atomic.AtomicInteger
class TestCowImpl : TestCowBaseImpl(), TestCow { class TestCowImpl : TestCowBaseImpl(),
TestCow {
companion object { companion object {
// has to start at 1 // has to start at 1