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

More conversion to kotlin

Browse Source
This commit is contained in:
nathan 2020-08-27 13:46:14 +02:00
parent 88c5644046
commit 59d58f27e8
1 changed files with 36 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
test/dorkboxTest/network/ListenerTest.kt
View File

@ -40,33 +40,33 @@ import dorkbox.network.connection.Connection
import dorkbox.network.connection.ConnectionParams import dorkbox.network.connection.ConnectionParams
import dorkbox.util.exceptions.InitializationException import dorkbox.util.exceptions.InitializationException
import dorkbox.util.exceptions.SecurityException import dorkbox.util.exceptions.SecurityException
import kotlinx.atomicfu.atomic
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test
import java.io.IOException import java.io.IOException
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
class ListenerTest : BaseTest() { class ListenerTest : BaseTest() {
private val origString = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" // lots of a's to encourage compression private val origString = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
private val limit = 20 private val limit = 20
private val count = AtomicInteger(0)
var checkFail1 = AtomicBoolean(false)
var checkFail2 = AtomicBoolean(false)
var overrideCheck = AtomicBoolean(false) private val count = atomic(0)
var serverOnMessage = AtomicBoolean(false) var checkFail1 = atomic(false)
var serverConnectionOnMessage = AtomicBoolean(false) var checkFail2 = atomic(false)
var serverDisconnectMessage = AtomicBoolean(false)
var serverConnect = AtomicBoolean(false) var overrideCheck = atomic(false)
var serverDisconnect = AtomicBoolean(false) var serverOnMessage = atomic(false)
var clientConnect = AtomicBoolean(false) var serverConnectionOnMessage = atomic(false)
var clientDisconnect = AtomicBoolean(false) var serverDisconnectMessage = atomic(false)
var serverConnect = atomic(false)
var serverDisconnect = atomic(false)
var clientConnect = atomic(false)
var clientDisconnect = atomic(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(connectionParameters: ConnectionParams<TestConnectionA>) : Connection(connectionParameters) { internal open inner class TestConnectionA(connectionParameters: ConnectionParams<TestConnectionA>) : Connection(connectionParameters) {
open fun check() { open fun check() {
overrideCheck.set(true) overrideCheck.value = true
} }
} }
@ -91,24 +91,25 @@ class ListenerTest : BaseTest() {
// generic listener // generic listener
server.onMessage<Any> { _, _ -> server.onMessage<Any> { _, _ ->
// should be called! // should be called!
serverOnMessage.set(true) serverOnMessage.value = true
} }
// standard connect check // standard connect check
server.onConnect { connection -> server.onConnect { connection ->
serverConnect.set(true) serverConnect.value = true
connection.onMessage<Any> {_, _ -> connection.onMessage<Any> {_, _ ->
serverConnectionOnMessage.set(true) serverConnectionOnMessage.value = true
} }
connection.onDisconnect { _ -> connection.onDisconnect { _ ->
serverDisconnectMessage.set(true) serverDisconnectMessage.value = true
} }
} }
// standard listener disconnect check // standard listener disconnect check
server.onDisconnect { server.onDisconnect { connection ->
serverDisconnect.set(true) serverDisconnect.value = true
} }
@ -135,7 +136,7 @@ class ListenerTest : BaseTest() {
client.onMessage<String> { connection, message -> client.onMessage<String> { connection, message ->
if (origString != message) { if (origString != message) {
checkFail2.set(true) checkFail2.value = true
System.err.println("original string not equal to the string received") System.err.println("original string not equal to the string received")
stopEndPoints() stopEndPoints()
return@onMessage return@onMessage
@ -150,13 +151,13 @@ class ListenerTest : BaseTest() {
// standard connect check // standard connect check
client.onConnect { client.onConnect {
clientConnect.set(true) clientConnect.value = true
} }
// standard listener disconnect check // standard listener disconnect check
client.onDisconnect { client.onDisconnect {
clientDisconnect.set(true) clientDisconnect.value = true
} }
@ -167,17 +168,17 @@ class ListenerTest : BaseTest() {
waitForThreads() waitForThreads()
// -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, count.value - 1)
Assert.assertTrue(overrideCheck.get()) Assert.assertTrue(overrideCheck.value)
Assert.assertTrue(serverOnMessage.get()) Assert.assertTrue(serverOnMessage.value)
Assert.assertTrue(serverConnectionOnMessage.get()) Assert.assertTrue(serverConnectionOnMessage.value)
Assert.assertTrue(serverDisconnectMessage.get()) Assert.assertTrue(serverDisconnectMessage.value)
Assert.assertTrue(serverConnect.get()) Assert.assertTrue(serverConnect.value)
Assert.assertTrue(serverDisconnect.get()) Assert.assertTrue(serverDisconnect.value)
Assert.assertTrue(clientConnect.get()) Assert.assertTrue(clientConnect.value)
Assert.assertTrue(clientDisconnect.get()) Assert.assertTrue(clientDisconnect.value)
Assert.assertFalse(checkFail1.get()) Assert.assertFalse(checkFail1.value)
Assert.assertFalse(checkFail2.get()) Assert.assertFalse(checkFail2.value)
} }
} }