Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • justJanne/libquassel
1 result
Select Git revision
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 299 additions and 3537 deletions
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/NetworkInfoSerializerTest.kt
View file @ ebf80ffc
......@@ -9,7 +9,7 @@
package de.justjanne.libquassel.protocol.serializers.quassel
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.models.network.NetworkInfo
import de.justjanne.libquassel.protocol.models.network.NetworkInfoDto
import de.justjanne.libquassel.protocol.models.types.QuasselType
import de.justjanne.libquassel.protocol.testutil.byteBufferOf
import de.justjanne.libquassel.protocol.testutil.primitiveSerializerTest
......@@ -23,98 +23,103 @@ class NetworkInfoSerializerTest {
fun testIsRegistered() {
assertEquals(
NetworkInfoSerializer,
QuasselType.NetworkInfo.serializer<NetworkInfo>(),
QuasselType.NetworkInfo.serializer<NetworkInfoDto>(),
)
}
@Test
fun testEmptyMap() = primitiveSerializerTest(
NetworkInfoSerializer,
NetworkInfo(),
byteBufferOf(
// no elements
0x00u, 0x00u, 0x00u, 0x00u,
),
featureSets = emptyList(),
serializeFeatureSet = null
)
fun testEmptyMap() =
primitiveSerializerTest(
NetworkInfoSerializer,
NetworkInfoDto(),
byteBufferOf(
// no elements
0x00u,
0x00u,
0x00u,
0x00u,
),
featureSets = emptyList(),
serializeFeatureSet = null,
)
@Test
fun testNormal() = primitiveSerializerTest(
NetworkInfoSerializer,
NetworkInfo(
networkId = NetworkId(4),
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x19u, 0x00u, 0x00u, 0x00u, 0x12u, 0x00u, 0x4Eu, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x77u,
0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x6Bu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x7Fu, 0x00u, 0x00u,
0x00u, 0x00u, 0x0Au, 0x4Eu, 0x65u, 0x74u, 0x77u, 0x6Fu, 0x72u, 0x6Bu, 0x49u, 0x64u, 0x00u, 0x00u, 0x00u, 0x00u,
0x04u, 0x00u, 0x00u, 0x00u, 0x16u, 0x00u, 0x4Eu, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u,
0x72u, 0x00u, 0x6Bu, 0x00u, 0x4Eu, 0x00u, 0x61u, 0x00u, 0x6Du, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x10u, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x74u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x7Fu, 0x00u, 0x00u, 0x00u, 0x00u,
0x0Bu, 0x49u, 0x64u, 0x65u, 0x6Eu, 0x74u, 0x69u, 0x74u, 0x79u, 0x49u, 0x64u, 0x00u, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
0x00u, 0x00u, 0x00u, 0x24u, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x43u, 0x00u, 0x75u, 0x00u, 0x73u,
0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x6Du, 0x00u, 0x45u, 0x00u, 0x6Eu, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u,
0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x67u, 0x00u, 0x73u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x1Cu, 0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu,
0x00u, 0x72u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x00u,
0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u, 0x00u, 0x00u, 0x00u, 0x20u,
0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu, 0x00u, 0x72u,
0x00u, 0x45u, 0x00u, 0x6Eu, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x67u,
0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u, 0x00u, 0x00u,
0x00u, 0x20u, 0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu,
0x00u, 0x72u, 0x00u, 0x44u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x69u, 0x00u, 0x6Eu,
0x00u, 0x67u, 0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u,
0x00u, 0x00u, 0x00u, 0x14u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x65u, 0x00u, 0x72u,
0x00u, 0x4Cu, 0x00u, 0x69u, 0x00u, 0x73u, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x09u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u,
0x6Eu, 0x00u, 0x64u, 0x00u, 0x6Fu, 0x00u, 0x6Du, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u,
0x65u, 0x00u, 0x72u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Eu, 0x00u, 0x50u, 0x00u,
0x65u, 0x00u, 0x72u, 0x00u, 0x66u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x6Du, 0x00u, 0x00u, 0x00u, 0x0Bu, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x41u,
0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu, 0x00u, 0x74u,
0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x26u,
0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u,
0x00u, 0x69u, 0x00u, 0x63u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x28u, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u,
0x65u, 0x00u, 0x6Eu, 0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x50u, 0x00u, 0x61u, 0x00u,
0x73u, 0x00u, 0x73u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x53u,
0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x16u,
0x00u, 0x53u, 0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x41u, 0x00u, 0x63u, 0x00u, 0x63u, 0x00u, 0x6Fu,
0x00u, 0x75u, 0x00u, 0x6Eu, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x18u, 0x00u, 0x53u, 0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x50u, 0x00u, 0x61u, 0x00u,
0x73u, 0x00u, 0x73u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x20u, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x41u,
0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu,
0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u,
0x00u, 0x2Au, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u,
0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u, 0x00u, 0x49u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x61u, 0x00u, 0x6Cu, 0x00u, 0x00u, 0x00u, 0x03u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x28u, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u,
0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u,
0x63u, 0x00u, 0x74u, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x72u, 0x00u, 0x69u, 0x00u, 0x65u, 0x00u,
0x73u, 0x00u, 0x00u, 0x00u, 0x85u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x32u, 0x00u, 0x55u, 0x00u, 0x6Eu,
0x00u, 0x6Cu, 0x00u, 0x69u, 0x00u, 0x6Du, 0x00u, 0x69u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x64u, 0x00u, 0x52u,
0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u,
0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x72u, 0x00u, 0x69u, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x00u,
0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x1Cu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x6Au, 0x00u, 0x6Fu,
0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x43u, 0x00u, 0x68u, 0x00u, 0x61u, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u,
0x00u, 0x6Cu, 0x00u, 0x73u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x28u, 0x00u, 0x55u,
0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x43u, 0x00u, 0x75u, 0x00u, 0x73u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x6Du,
0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u, 0x00u, 0x65u, 0x00u, 0x52u,
0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x28u,
0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u, 0x00u, 0x65u, 0x00u, 0x52u,
0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x42u, 0x00u, 0x75u, 0x00u, 0x72u, 0x00u, 0x73u, 0x00u, 0x74u,
0x00u, 0x53u, 0x00u, 0x69u, 0x00u, 0x7Au, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x20u, 0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u,
0x67u, 0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x44u, 0x00u, 0x65u, 0x00u,
0x6Cu, 0x00u, 0x61u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x28u, 0x00u, 0x55u, 0x00u, 0x6Eu, 0x00u, 0x6Cu, 0x00u, 0x69u, 0x00u, 0x6Du, 0x00u, 0x69u, 0x00u, 0x74u,
0x00u, 0x65u, 0x00u, 0x64u, 0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u,
0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u,
fun testNormal() =
primitiveSerializerTest(
NetworkInfoSerializer,
NetworkInfoDto(
networkId = NetworkId(4),
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x19u, 0x00u, 0x00u, 0x00u, 0x12u, 0x00u, 0x4Eu, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x77u,
0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x6Bu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x7Fu, 0x00u, 0x00u,
0x00u, 0x00u, 0x0Au, 0x4Eu, 0x65u, 0x74u, 0x77u, 0x6Fu, 0x72u, 0x6Bu, 0x49u, 0x64u, 0x00u, 0x00u, 0x00u, 0x00u,
0x04u, 0x00u, 0x00u, 0x00u, 0x16u, 0x00u, 0x4Eu, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u,
0x72u, 0x00u, 0x6Bu, 0x00u, 0x4Eu, 0x00u, 0x61u, 0x00u, 0x6Du, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x10u, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x74u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x7Fu, 0x00u, 0x00u, 0x00u, 0x00u,
0x0Bu, 0x49u, 0x64u, 0x65u, 0x6Eu, 0x74u, 0x69u, 0x74u, 0x79u, 0x49u, 0x64u, 0x00u, 0xFFu, 0xFFu, 0xFFu, 0xFFu,
0x00u, 0x00u, 0x00u, 0x24u, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x43u, 0x00u, 0x75u, 0x00u, 0x73u,
0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x6Du, 0x00u, 0x45u, 0x00u, 0x6Eu, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u,
0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x67u, 0x00u, 0x73u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x1Cu, 0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu,
0x00u, 0x72u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x00u,
0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u, 0x00u, 0x00u, 0x00u, 0x20u,
0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu, 0x00u, 0x72u,
0x00u, 0x45u, 0x00u, 0x6Eu, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x67u,
0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u, 0x00u, 0x00u,
0x00u, 0x20u, 0x00u, 0x43u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x46u, 0x00u, 0x6Fu,
0x00u, 0x72u, 0x00u, 0x44u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x64u, 0x00u, 0x69u, 0x00u, 0x6Eu,
0x00u, 0x67u, 0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x55u, 0x54u, 0x46u, 0x5Fu, 0x38u,
0x00u, 0x00u, 0x00u, 0x14u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x65u, 0x00u, 0x72u,
0x00u, 0x4Cu, 0x00u, 0x69u, 0x00u, 0x73u, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x09u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u,
0x6Eu, 0x00u, 0x64u, 0x00u, 0x6Fu, 0x00u, 0x6Du, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u,
0x65u, 0x00u, 0x72u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Eu, 0x00u, 0x50u, 0x00u,
0x65u, 0x00u, 0x72u, 0x00u, 0x66u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x6Du, 0x00u, 0x00u, 0x00u, 0x0Bu, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x1Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x41u,
0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu, 0x00u, 0x74u,
0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x26u,
0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u, 0x65u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x53u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u,
0x00u, 0x69u, 0x00u, 0x63u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x28u, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x49u, 0x00u, 0x64u, 0x00u,
0x65u, 0x00u, 0x6Eu, 0x00u, 0x74u, 0x00u, 0x69u, 0x00u, 0x66u, 0x00u, 0x79u, 0x00u, 0x50u, 0x00u, 0x61u, 0x00u,
0x73u, 0x00u, 0x73u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Eu, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x53u,
0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x16u,
0x00u, 0x53u, 0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x41u, 0x00u, 0x63u, 0x00u, 0x63u, 0x00u, 0x6Fu,
0x00u, 0x75u, 0x00u, 0x6Eu, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x18u, 0x00u, 0x53u, 0x00u, 0x61u, 0x00u, 0x73u, 0x00u, 0x6Cu, 0x00u, 0x50u, 0x00u, 0x61u, 0x00u,
0x73u, 0x00u, 0x73u, 0x00u, 0x77u, 0x00u, 0x6Fu, 0x00u, 0x72u, 0x00u, 0x64u, 0x00u, 0x00u, 0x00u, 0x0Au, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x20u, 0x00u, 0x55u, 0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x41u,
0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu,
0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u,
0x00u, 0x2Au, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u,
0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u, 0x00u, 0x49u, 0x00u, 0x6Eu,
0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x72u, 0x00u, 0x76u, 0x00u, 0x61u, 0x00u, 0x6Cu, 0x00u, 0x00u, 0x00u, 0x03u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x28u, 0x00u, 0x41u, 0x00u, 0x75u, 0x00u, 0x74u, 0x00u,
0x6Fu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u,
0x63u, 0x00u, 0x74u, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x72u, 0x00u, 0x69u, 0x00u, 0x65u, 0x00u,
0x73u, 0x00u, 0x00u, 0x00u, 0x85u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x32u, 0x00u, 0x55u, 0x00u, 0x6Eu,
0x00u, 0x6Cu, 0x00u, 0x69u, 0x00u, 0x6Du, 0x00u, 0x69u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x64u, 0x00u, 0x52u,
0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x6Fu, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u, 0x00u, 0x63u, 0x00u, 0x74u,
0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x74u, 0x00u, 0x72u, 0x00u, 0x69u, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x00u,
0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x1Cu, 0x00u, 0x52u, 0x00u, 0x65u, 0x00u, 0x6Au, 0x00u, 0x6Fu,
0x00u, 0x69u, 0x00u, 0x6Eu, 0x00u, 0x43u, 0x00u, 0x68u, 0x00u, 0x61u, 0x00u, 0x6Eu, 0x00u, 0x6Eu, 0x00u, 0x65u,
0x00u, 0x6Cu, 0x00u, 0x73u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x28u, 0x00u, 0x55u,
0x00u, 0x73u, 0x00u, 0x65u, 0x00u, 0x43u, 0x00u, 0x75u, 0x00u, 0x73u, 0x00u, 0x74u, 0x00u, 0x6Fu, 0x00u, 0x6Du,
0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u, 0x00u, 0x65u, 0x00u, 0x52u,
0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x28u,
0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u, 0x00u, 0x65u, 0x00u, 0x52u,
0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x42u, 0x00u, 0x75u, 0x00u, 0x72u, 0x00u, 0x73u, 0x00u, 0x74u,
0x00u, 0x53u, 0x00u, 0x69u, 0x00u, 0x7Au, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x20u, 0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u,
0x67u, 0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x44u, 0x00u, 0x65u, 0x00u,
0x6Cu, 0x00u, 0x61u, 0x00u, 0x79u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x28u, 0x00u, 0x55u, 0x00u, 0x6Eu, 0x00u, 0x6Cu, 0x00u, 0x69u, 0x00u, 0x6Du, 0x00u, 0x69u, 0x00u, 0x74u,
0x00u, 0x65u, 0x00u, 0x64u, 0x00u, 0x4Du, 0x00u, 0x65u, 0x00u, 0x73u, 0x00u, 0x73u, 0x00u, 0x61u, 0x00u, 0x67u,
0x00u, 0x65u, 0x00u, 0x52u, 0x00u, 0x61u, 0x00u, 0x74u, 0x00u, 0x65u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u,
),
)
)
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/PeerPtrSerializerTest.kt
View file @ ebf80ffc
......@@ -27,34 +27,38 @@ class PeerPtrSerializerTest {
}
@Test
fun testZero() = primitiveSerializerTest(
PeerPtrSerializer,
0uL,
byteBufferOf(0, 0, 0, 0, 0, 0, 0, 0),
featureSets = listOf(FeatureSet.all())
)
fun testZero() =
primitiveSerializerTest(
PeerPtrSerializer,
0uL,
byteBufferOf(0, 0, 0, 0, 0, 0, 0, 0),
featureSets = listOf(FeatureSet.all()),
)
@Test
fun testMinimal() = primitiveSerializerTest(
PeerPtrSerializer,
ULong.MIN_VALUE,
byteBufferOf(0, 0, 0, 0, 0, 0, 0, 0),
featureSets = listOf(FeatureSet.all())
)
fun testMinimal() =
primitiveSerializerTest(
PeerPtrSerializer,
ULong.MIN_VALUE,
byteBufferOf(0, 0, 0, 0, 0, 0, 0, 0),
featureSets = listOf(FeatureSet.all()),
)
@Test
fun testMaximal() = primitiveSerializerTest(
PeerPtrSerializer,
ULong.MAX_VALUE,
byteBufferOf(-1, -1, -1, -1, -1, -1, -1, -1),
featureSets = listOf(FeatureSet.all())
)
fun testMaximal() =
primitiveSerializerTest(
PeerPtrSerializer,
ULong.MAX_VALUE,
byteBufferOf(-1, -1, -1, -1, -1, -1, -1, -1),
featureSets = listOf(FeatureSet.all()),
)
@Test
fun testAllOnes() = primitiveSerializerTest(
PeerPtrSerializer,
0uL.inv(),
byteBufferOf(-1, -1, -1, -1, -1, -1, -1, -1),
featureSets = listOf(FeatureSet.all())
)
fun testAllOnes() =
primitiveSerializerTest(
PeerPtrSerializer,
0uL.inv(),
byteBufferOf(-1, -1, -1, -1, -1, -1, -1, -1),
featureSets = listOf(FeatureSet.all()),
)
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/QHostAddressSerializerTest.kt
View file @ ebf80ffc
......@@ -29,30 +29,40 @@ class QHostAddressSerializerTest {
}
@Test
fun testIpv4() = primitiveSerializerTest(
QHostAddressSerializer,
Inet4Address.getByAddress(
byteArrayOf(
127, 0, 0, 1
)
),
byteBufferOf(
0x00,
127, 0, 0, 1
fun testIpv4() =
primitiveSerializerTest(
QHostAddressSerializer,
Inet4Address.getByAddress(
byteArrayOf(
127,
0,
0,
1,
),
),
byteBufferOf(
0x00,
127,
0,
0,
1,
),
)
)
@Test
fun testIpv6() = primitiveSerializerTest(
QHostAddressSerializer,
Inet6Address.getByAddress(
ubyteArrayOf(
0x26u, 0x07u, 0xf1u, 0x88u, 0x00u, 0x00u, 0x00u, 0x00u, 0xdeu, 0xadu, 0xbeu, 0xefu, 0xcau, 0xfeu, 0xfeu, 0xd1u,
).toByteArray()
),
byteBufferOf(
0x01u,
0x26u, 0x07u, 0xf1u, 0x88u, 0x00u, 0x00u, 0x00u, 0x00u, 0xdeu, 0xadu, 0xbeu, 0xefu, 0xcau, 0xfeu, 0xfeu, 0xd1u,
fun testIpv6() =
primitiveSerializerTest(
QHostAddressSerializer,
Inet6Address.getByAddress(
ubyteArrayOf(
0x26u, 0x07u, 0xf1u, 0x88u, 0x00u, 0x00u, 0x00u, 0x00u,
0xdeu, 0xadu, 0xbeu, 0xefu, 0xcau, 0xfeu, 0xfeu, 0xd1u,
).toByteArray(),
),
byteBufferOf(
0x01u,
0x26u, 0x07u, 0xf1u, 0x88u, 0x00u, 0x00u, 0x00u, 0x00u,
0xdeu, 0xadu, 0xbeu, 0xefu, 0xcau, 0xfeu, 0xfeu, 0xd1u,
),
)
)
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/HeartBeatReplySerializerTest.kt
View file @ ebf80ffc
......@@ -18,42 +18,45 @@ import org.threeten.bp.Instant
@Tag("SignalProxySerializerTest")
class HeartBeatReplySerializerTest {
@Test
fun testEmptyMap() = signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.EPOCH
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// HeartBeatReply
0x00u, 0x00u, 0x00u, 0x06u,
),
featureSets = emptyList(),
serializeFeatureSet = null
)
fun testEmptyMap() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.EPOCH,
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// HeartBeatReply
0x00u, 0x00u, 0x00u, 0x06u,
),
featureSets = emptyList(),
serializeFeatureSet = null,
)
@Test
fun testSimple() = signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.EPOCH
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x06u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x3Du, 0x8Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u,
fun testSimple() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.EPOCH,
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x06u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x3Du, 0x8Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u,
),
)
)
@Test
fun testRealistic() = signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.ofEpochMilli(1614520296337)
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x06u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x86u, 0x8Au, 0x02u, 0xF9u, 0x5Bu, 0x91u, 0x02u,
fun testRealistic() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeatReply(
Instant.ofEpochMilli(1614520296337),
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x06u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x86u, 0x8Au, 0x02u, 0xF9u, 0x5Bu, 0x91u, 0x02u,
),
)
)
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/HeartBeatSerializerTest.kt
View file @ ebf80ffc
......@@ -18,42 +18,45 @@ import org.threeten.bp.Instant
@Tag("SignalProxySerializerTest")
class HeartBeatSerializerTest {
@Test
fun testEmptyMap() = signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.EPOCH
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// HeartBeat
0x00u, 0x00u, 0x00u, 0x05u,
),
featureSets = emptyList(),
serializeFeatureSet = null
)
fun testEmptyMap() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.EPOCH,
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// HeartBeat
0x00u, 0x00u, 0x00u, 0x05u,
),
featureSets = emptyList(),
serializeFeatureSet = null,
)
@Test
fun testSimple() = signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.EPOCH
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x3Du, 0x8Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u,
fun testSimple() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.EPOCH,
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x3Du, 0x8Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u,
),
)
)
@Test
fun testRealistic() = signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.ofEpochMilli(1614520296337)
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x86u, 0x8Au, 0x02u, 0xF9u, 0x5Bu, 0x91u, 0x02u,
fun testRealistic() =
signalProxySerializerTest(
SignalProxyMessage.HeartBeat(
Instant.ofEpochMilli(1614520296337),
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x05u, 0x00u, 0x00u, 0x00u,
0x10u, 0x00u, 0x00u, 0x25u, 0x86u, 0x8Au, 0x02u, 0xF9u, 0x5Bu, 0x91u, 0x02u,
),
)
)
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/InitDataSerializerTest.kt
View file @ ebf80ffc
......@@ -9,9 +9,6 @@
package de.justjanne.libquassel.protocol.serializers.signalproxy
import de.justjanne.libquassel.protocol.models.SignalProxyMessage
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.syncables.common.Network
import de.justjanne.libquassel.protocol.syncables.state.NetworkState
import de.justjanne.libquassel.protocol.testutil.byteBufferOf
import de.justjanne.libquassel.protocol.testutil.signalProxySerializerTest
import org.junit.jupiter.api.Tag
......@@ -52,6 +49,7 @@ class InitDataSerializerTest {
)
)
/*
@Test
fun testRealistic() {
signalProxySerializerTest(
......@@ -142,4 +140,5 @@ class InitDataSerializerTest {
)
)
}
*/
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/InitRequestSerializerTest.kt
View file @ ebf80ffc
......@@ -17,48 +17,50 @@ import org.junit.jupiter.api.Test
@Tag("SignalProxySerializerTest")
class InitRequestSerializerTest {
@Test
fun testEmptyMap() = signalProxySerializerTest(
SignalProxyMessage.InitRequest(
className = "",
objectName = ""
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// Rpc
0x00u, 0x00u, 0x00u, 0x03u,
),
featureSets = emptyList(),
serializeFeatureSet = null
)
fun testEmptyMap() =
signalProxySerializerTest(
SignalProxyMessage.InitRequest(
className = "",
objectName = "",
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// Rpc
0x00u, 0x00u, 0x00u, 0x03u,
),
featureSets = emptyList(),
serializeFeatureSet = null,
)
@Test
fun testSimple() = signalProxySerializerTest(
SignalProxyMessage.InitRequest(
className = "",
objectName = ""
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
fun testSimple() =
signalProxySerializerTest(
SignalProxyMessage.InitRequest(
className = "",
objectName = "",
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
),
)
)
@Test
fun testRealistic() {
signalProxySerializerTest(
SignalProxyMessage.InitRequest(
className = "Network",
objectName = "4"
objectName = "4",
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x03u, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x07u, 0x4Eu, 0x65u, 0x74u, 0x77u, 0x6Fu, 0x72u, 0x6Bu, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x01u, 0x34u,
)
),
)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/RpcSerializerTest.kt
View file @ ebf80ffc
......@@ -9,6 +9,7 @@
package de.justjanne.libquassel.protocol.serializers.signalproxy
import de.justjanne.libquassel.protocol.models.SignalProxyMessage
import de.justjanne.libquassel.protocol.models.network.IdentityDto
import de.justjanne.libquassel.protocol.models.types.QtType
import de.justjanne.libquassel.protocol.models.types.QuasselType
import de.justjanne.libquassel.protocol.testutil.byteBufferOf
......@@ -21,51 +22,55 @@ import org.junit.jupiter.api.Test
@Tag("SignalProxySerializerTest")
class RpcSerializerTest {
@Test
fun testEmptyMap() = signalProxySerializerTest(
SignalProxyMessage.Rpc(
slotName = "",
params = emptyList()
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// Rpc
0x00u, 0x00u, 0x00u, 0x02u,
),
featureSets = emptyList(),
serializeFeatureSet = null
)
fun testEmptyMap() =
signalProxySerializerTest(
SignalProxyMessage.Rpc(
slotName = "",
params = emptyList(),
),
byteBufferOf(
// 4 elements
0x00u, 0x00u, 0x00u, 0x01u,
// int
0x00u, 0x00u, 0x00u, 0x02u,
0x00u,
// Rpc
0x00u, 0x00u, 0x00u, 0x02u,
),
featureSets = emptyList(),
serializeFeatureSet = null,
)
@Test
fun testSimple() = signalProxySerializerTest(
SignalProxyMessage.Rpc(
slotName = "",
params = emptyList()
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
fun testSimple() =
signalProxySerializerTest(
SignalProxyMessage.Rpc(
slotName = "",
params = emptyList(),
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u,
0x0Cu, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
),
)
)
/*
@Test
fun testRealistic() {
signalProxySerializerTest(
SignalProxyMessage.Rpc(
slotName = "2createIdentity(Identity,QVariantMap)",
params = listOf(
qVariant(
emptyMap(),
QuasselType.Identity
params =
listOf(
qVariant(
IdentityDto(),
QuasselType.Identity,
),
qVariant(
emptyMap<String, QVariant_>(),
QtType.QVariantMap,
),
),
qVariant(
emptyMap<String, QVariant_>(),
QtType.QVariantMap
)
)
),
byteBufferOf(
0x00u, 0x00u, 0x00u, 0x04u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x02u, 0x00u, 0x00u, 0x00u,
......@@ -74,7 +79,8 @@ class RpcSerializerTest {
0x56u, 0x61u, 0x72u, 0x69u, 0x61u, 0x6Eu, 0x74u, 0x4Du, 0x61u, 0x70u, 0x29u, 0x00u, 0x00u, 0x00u, 0x7Fu, 0x00u,
0x00u, 0x00u, 0x00u, 0x09u, 0x49u, 0x64u, 0x65u, 0x6Eu, 0x74u, 0x69u, 0x74u, 0x79u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x08u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
)
),
)
}
*/
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/serializers/signalproxy/SyncSerializerTest.kt
View file @ ebf80ffc
......@@ -9,13 +9,8 @@
package de.justjanne.libquassel.protocol.serializers.signalproxy
import de.justjanne.libquassel.protocol.models.SignalProxyMessage
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.models.types.QtType
import de.justjanne.libquassel.protocol.syncables.common.Network
import de.justjanne.libquassel.protocol.syncables.state.NetworkState
import de.justjanne.libquassel.protocol.testutil.byteBufferOf
import de.justjanne.libquassel.protocol.testutil.signalProxySerializerTest
import de.justjanne.libquassel.protocol.variant.qVariant
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
......@@ -57,9 +52,9 @@ class SyncSerializerTest {
)
)
/*
@Test
fun testRealistic() {
signalProxySerializerTest(
SignalProxyMessage.Sync(
className = "Network",
......@@ -174,4 +169,5 @@ class SyncSerializerTest {
)
)
}
*/
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/AliasManagerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.bitflags.of
import de.justjanne.libquassel.protocol.models.BufferInfo
import de.justjanne.libquassel.protocol.models.QStringList
import de.justjanne.libquassel.protocol.models.alias.Alias
import de.justjanne.libquassel.protocol.models.alias.Command
import de.justjanne.libquassel.protocol.models.flags.BufferType
import de.justjanne.libquassel.protocol.models.ids.BufferId
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.models.types.QtType
import de.justjanne.libquassel.protocol.session.Session
import de.justjanne.libquassel.protocol.syncables.common.AliasManager
import de.justjanne.libquassel.protocol.syncables.state.AliasManagerState
import de.justjanne.libquassel.protocol.testutil.mocks.EmptySession
import de.justjanne.libquassel.protocol.testutil.mocks.RealisticSession
import de.justjanne.libquassel.protocol.testutil.nextAliasManager
import de.justjanne.libquassel.protocol.testutil.nextString
import de.justjanne.libquassel.protocol.variant.QVariantMap
import de.justjanne.libquassel.protocol.variant.qVariant
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import kotlin.random.Random
class AliasManagerTest {
@Test
fun testEmpty() {
val actual = AliasManager().apply {
update(emptyMap())
}.state()
assertEquals(AliasManagerState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextAliasManager()
val actual = AliasManager().apply {
update(AliasManager(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Test
fun testInvalidData() {
val state = AliasManagerState()
AliasManager(state = state).apply {
assertThrows<IllegalArgumentException> {
update(
mapOf(
"Aliases" to qVariant<QVariantMap>(
mapOf(
"names" to qVariant(emptyList(), QtType.QStringList),
"expansions" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
}
}
@Nested
inner class AddAlias {
@Test
fun new() {
val random = Random(1337)
val value = AliasManager(
state = random.nextAliasManager()
)
val aliasCount = value.aliases().size
val alias = Alias(random.nextString(), random.nextString())
assertFalse(value.aliases().contains(alias))
value.addAlias(alias.name, alias.expansion)
assertEquals(aliasCount + 1, value.aliases().size)
assertTrue(value.aliases().contains(alias))
assertEquals(aliasCount, value.indexOf(alias.name))
}
@Test
fun existing() {
val random = Random(1337)
val value = AliasManager(
state = random.nextAliasManager()
)
val aliasCount = value.aliases().size
val alias = value.aliases().first()
assertTrue(value.aliases().contains(alias))
value.addAlias(alias.name, alias.expansion)
assertEquals(aliasCount, value.aliases().size)
assertTrue(value.aliases().contains(alias))
}
}
@Nested
inner class Expansion {
@Test
fun plaintext() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"this is some text",
"/SAY this is some text"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"this is some text",
"/SAY this is some text"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"this is some text",
"/SAY this is some text"
)
}
@Test
fun say() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/say this is some text",
"/say this is some text"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/say this is some text",
"/say this is some text"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/say this is some text",
"/say this is some text"
)
}
@Test
fun userExpansionWithIdentd() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion justJanne",
"justJanne * * * *"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion justJanne",
"justJanne * * * *"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion justJanne",
"justJanne justJanne kuschku.de kuschku kuschku"
)
}
@Test
fun userExpansionNoIdentd() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion digitalcircuit",
"digitalcircuit * * * *"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion digitalcircuit",
"digitalcircuit * * * *"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion digitalcircuit",
"digitalcircuit digitalcircuit 2605:6000:1518:830d:ec4:7aff:fe6b:c6b0 * ~quassel"
)
}
@Test
fun userExpansionUnknownUser() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion ChanServ",
"ChanServ * * * *"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion ChanServ",
"ChanServ * * * *"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion ChanServ",
"ChanServ * * * *"
)
}
@Test
fun userExpansionNoParams() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion",
"\$1 \$1:account \$1:hostname \$1:identd \$1:ident"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion",
"\$1 \$1:account \$1:hostname \$1:identd \$1:ident"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/userexpansion",
"\$1 \$1:account \$1:hostname \$1:identd \$1:ident"
)
}
@Test
fun userExpansionQuery() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/userexpansion digitalcircuit",
"digitalcircuit * * * *"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/userexpansion digitalcircuit",
"digitalcircuit * * * *"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/userexpansion digitalcircuit",
"digitalcircuit digitalcircuit 2605:6000:1518:830d:ec4:7aff:fe6b:c6b0 * ~quassel"
)
}
@Test
fun channelExpansionChannel() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/constantexpansion 12 3",
"#quassel-test \$currentnick \$network 12 3"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/constantexpansion 12 3",
"#quassel-test \$currentnick \$network 12 3"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(1),
networkId = NetworkId(1),
bufferName = "#quassel-test",
type = BufferType.of(BufferType.Channel)
),
"/constantexpansion 12 3",
"#quassel-test justJanne FreeNode 12 3"
)
}
@Test
fun channelExpansionQuery() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/constantexpansion 12 3",
"digitalcircuit \$currentnick \$network 12 3"
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/constantexpansion 12 3",
"digitalcircuit \$currentnick \$network 12 3"
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/constantexpansion 12 3",
"digitalcircuit justJanne FreeNode 12 3"
)
}
@Test
fun rangeExpansion() {
testExpansion(
null,
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/rangeexpansion a b c d e f",
"1 \"a\" 2 \"b\" 3..4 \"c d\" 3.. \"c d e f\""
)
testExpansion(
EmptySession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/rangeexpansion a b c d e f",
"1 \"a\" 2 \"b\" 3..4 \"c d\" 3.. \"c d e f\""
)
testExpansion(
RealisticSession(),
BufferInfo(
bufferId = BufferId(3),
networkId = NetworkId(1),
bufferName = "digitalcircuit",
type = BufferType.of(BufferType.Query)
),
"/rangeexpansion a b c d e f",
"1 \"a\" 2 \"b\" 3..4 \"c d\" 3.. \"c d e f\""
)
}
private fun testExpansion(
session: Session?,
buffer: BufferInfo,
message: String,
expected: String
) {
val value = AliasManager(
session = session,
state = AliasManagerState(
aliases = listOf(
Alias(
"userexpansion",
"$1 $1:account $1:hostname $1:identd $1:ident"
),
Alias(
"constantexpansion",
"\$channel \$currentnick \$network \$0"
),
Alias(
"rangeexpansion",
"1 \"\$1\" 2 \"\$2\" 3..4 \"\$3..4\" 3.. \"\$3..\""
)
)
)
)
assertEquals(
listOf(
Command(
buffer,
expected
)
),
value.processInput(
buffer,
message
)
)
assertEquals(
listOf(
Command(
buffer,
expected
)
),
mutableListOf<Command>().also {
value.processInput(
buffer,
message,
it
)
}
)
}
}
@Nested
inner class DetermineMessageCommand {
@Test
fun plaintext() {
assertEquals(
Pair(null, "just some plain text"),
AliasManagerState.determineMessageCommand("just some plain text")
)
}
@Test
fun escaped() {
assertEquals(
Pair(null, "/escaped content"),
AliasManagerState.determineMessageCommand("//escaped content")
)
}
@Test
fun path() {
assertEquals(
Pair(null, "/bin/rm --rf /* is fun"),
AliasManagerState.determineMessageCommand("/bin/rm --rf /* is fun")
)
}
@Test
fun fakeItalic() {
assertEquals(
Pair(null, "/ suuuure /"),
AliasManagerState.determineMessageCommand("/ suuuure /")
)
}
@Test
fun command() {
assertEquals(
Pair("command", ""),
AliasManagerState.determineMessageCommand("/command")
)
}
@Test
fun commandWithParam() {
assertEquals(
Pair("command", "parameters are nice"),
AliasManagerState.determineMessageCommand("/command parameters are nice")
)
}
@Test
fun commandWithWhitespace() {
assertEquals(
Pair("command", " parameters are nice"),
AliasManagerState.determineMessageCommand("/command parameters are nice")
)
}
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/BufferSyncerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.syncables.common.BufferSyncer
import de.justjanne.libquassel.protocol.syncables.state.BufferSyncerState
import de.justjanne.libquassel.protocol.testutil.nextBufferSyncer
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import kotlin.random.Random
class BufferSyncerTest {
@Test
fun testEmpty() {
val actual = BufferSyncer().apply {
update(emptyMap())
}.state()
assertEquals(BufferSyncerState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextBufferSyncer()
// bufferInfos are not intended to be serialized
.copy(bufferInfos = emptyMap())
val actual = BufferSyncer().apply {
update(BufferSyncer(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/BufferViewConfigTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.bitflags.of
import de.justjanne.bitflags.toBits
import de.justjanne.libquassel.protocol.models.BufferActivity
import de.justjanne.libquassel.protocol.models.flags.BufferType
import de.justjanne.libquassel.protocol.models.ids.BufferId
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.syncables.common.BufferViewConfig
import de.justjanne.libquassel.protocol.syncables.state.BufferViewConfigState
import de.justjanne.libquassel.protocol.testutil.nextBufferViewConfig
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import kotlin.random.Random
class BufferViewConfigTest {
@Test
fun testEmpty() {
val state = BufferViewConfigState(bufferViewId = 1)
val actual = BufferViewConfig(state = state).apply {
update(emptyMap())
}.state()
assertEquals(state, actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextBufferViewConfig(bufferViewId = 1)
val actual = BufferViewConfig(
state = BufferViewConfigState(
bufferViewId = expected.bufferViewId,
)
).apply {
update(BufferViewConfig(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Nested
inner class AddBuffer {
@Test
fun new() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = BufferId(105)
value.addBuffer(buffer, 3)
assertEquals(3, value.buffers().indexOf(buffer))
assertEquals(bufferSize + 1, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun existing() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.buffers().first()
value.addBuffer(buffer, 3)
assertEquals(0, value.buffers().indexOf(buffer))
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun hidden() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.hiddenBuffers().first()
value.addBuffer(buffer, 3)
assertEquals(3, value.buffers().indexOf(buffer))
assertEquals(bufferSize + 1, value.buffers().size)
assertEquals(hiddenSize - 1, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun removed() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.removedBuffers().first()
value.addBuffer(buffer, 3)
assertEquals(3, value.buffers().indexOf(buffer))
assertEquals(bufferSize + 1, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize - 1, value.removedBuffers().size)
}
}
@Nested
inner class HideBuffer {
@Test
fun new() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = BufferId(105)
value.hideBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize + 1, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun existing() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.buffers().first()
value.hideBuffer(buffer)
assertEquals(bufferSize - 1, value.buffers().size)
assertEquals(hiddenSize + 1, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun hidden() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.hiddenBuffers().first()
value.hideBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun removed() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.removedBuffers().first()
value.hideBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize + 1, value.hiddenBuffers().size)
assertEquals(removedSize - 1, value.removedBuffers().size)
}
}
@Nested
inner class RemoveBuffer {
@Test
fun new() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = BufferId(105)
value.removeBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize + 1, value.removedBuffers().size)
}
@Test
fun existing() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.buffers().first()
value.removeBuffer(buffer)
assertEquals(bufferSize - 1, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize + 1, value.removedBuffers().size)
}
@Test
fun hidden() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.hiddenBuffers().first()
value.removeBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize - 1, value.hiddenBuffers().size)
assertEquals(removedSize + 1, value.removedBuffers().size)
}
@Test
fun removed() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.removedBuffers().first()
value.removeBuffer(buffer)
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
}
@Nested
inner class MoveBuffer {
@Test
fun new() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = BufferId(105)
value.moveBuffer(buffer, 3)
assertEquals(-1, value.buffers().indexOf(buffer))
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun existing() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.buffers().first()
value.moveBuffer(buffer, 3)
assertEquals(3, value.buffers().indexOf(buffer))
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun hidden() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.hiddenBuffers().first()
value.moveBuffer(buffer, 3)
assertEquals(-1, value.buffers().indexOf(buffer))
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
@Test
fun removed() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val bufferSize = value.buffers().size
val hiddenSize = value.hiddenBuffers().size
val removedSize = value.removedBuffers().size
val buffer = value.removedBuffers().first()
value.moveBuffer(buffer, 3)
assertEquals(-1, value.buffers().indexOf(buffer))
assertEquals(bufferSize, value.buffers().size)
assertEquals(hiddenSize, value.hiddenBuffers().size)
assertEquals(removedSize, value.removedBuffers().size)
}
}
@Nested
inner class Setters {
@Test
fun testBufferViewName() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val data = "All Chats"
assertNotEquals(data, value.bufferViewName())
value.setBufferViewName(data)
assertEquals(data, value.bufferViewName())
}
@Test
fun testAddNewBuffersAutomatically() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setAddNewBuffersAutomatically(false)
assertEquals(false, value.addNewBuffersAutomatically())
value.setAddNewBuffersAutomatically(true)
assertEquals(true, value.addNewBuffersAutomatically())
}
@Test
fun testAllowedBufferTypes() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val data = BufferType.of(
BufferType.Channel,
BufferType.Status,
BufferType.Query
)
assertNotEquals(data, value.allowedBufferTypes())
value.setAllowedBufferTypes(data.toBits().toInt())
assertEquals(data, value.allowedBufferTypes())
}
@Test
fun testDisableDecoration() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setDisableDecoration(false)
assertEquals(false, value.disableDecoration())
value.setDisableDecoration(true)
assertEquals(true, value.disableDecoration())
}
@Test
fun testHideInactiveBuffers() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setHideInactiveBuffers(false)
assertEquals(false, value.hideInactiveBuffers())
value.setHideInactiveBuffers(true)
assertEquals(true, value.hideInactiveBuffers())
}
@Test
fun testHideInactiveNetworks() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setHideInactiveNetworks(false)
assertEquals(false, value.hideInactiveNetworks())
value.setHideInactiveNetworks(true)
assertEquals(true, value.hideInactiveNetworks())
}
@Test
fun testMinimumActivity() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val data = BufferActivity.Highlight
assertNotEquals(data, value.minimumActivity())
value.setMinimumActivity(data.value)
assertEquals(data, value.minimumActivity())
}
@Test
fun testNetworkId() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
val data = NetworkId(random.nextInt())
assertNotEquals(data, value.networkId())
value.setNetworkId(data)
assertEquals(data, value.networkId())
}
@Test
fun testShowSearch() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setShowSearch(false)
assertEquals(false, value.showSearch())
value.setShowSearch(true)
assertEquals(true, value.showSearch())
}
@Test
fun testSortAlphabetically() {
val random = Random(1337)
val value = BufferViewConfig(
state = random.nextBufferViewConfig(bufferViewId = 1)
)
value.setSortAlphabetically(false)
assertEquals(false, value.sortAlphabetically())
value.setSortAlphabetically(true)
assertEquals(true, value.sortAlphabetically())
}
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/BufferViewManagerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.syncables.common.BufferViewManager
import de.justjanne.libquassel.protocol.syncables.state.BufferViewManagerState
import de.justjanne.libquassel.protocol.testutil.nextBufferViewManager
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import kotlin.random.Random
class BufferViewManagerTest {
@Test
fun testEmpty() {
val actual = BufferViewManager().apply {
update(emptyMap())
}.state()
assertEquals(BufferViewManagerState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextBufferViewManager()
val actual = BufferViewManager().apply {
update(BufferViewManager(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/CertManagerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.models.ids.IdentityId
import de.justjanne.libquassel.protocol.syncables.common.CertManager
import de.justjanne.libquassel.protocol.syncables.state.CertManagerState
import de.justjanne.libquassel.protocol.testutil.nextCertManager
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import kotlin.random.Random
class CertManagerTest {
@Test
fun testEmpty() {
val identityId = IdentityId(0)
val actual = CertManager(state = CertManagerState(identityId)).apply {
update(emptyMap())
}.state()
assertEquals(CertManagerState(identityId), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextCertManager()
val actual = CertManager(state = CertManagerState(identityId = expected.identityId)).apply {
update(CertManager(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/CoreInfoTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.syncables.common.CoreInfo
import de.justjanne.libquassel.protocol.syncables.state.CoreInfoState
import de.justjanne.libquassel.protocol.testutil.nextCoreInfo
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import kotlin.random.Random
class CoreInfoTest {
@Test
fun testEmpty() {
val actual = CoreInfo().apply {
update(emptyMap())
}.state()
assertEquals(CoreInfoState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextCoreInfo()
val actual = CoreInfo().apply {
update(CoreInfo(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/DccConfigTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.syncables.common.DccConfig
import de.justjanne.libquassel.protocol.syncables.state.DccConfigState
import de.justjanne.libquassel.protocol.testutil.nextDccConfig
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import kotlin.random.Random
class DccConfigTest {
@Test
fun testEmpty() {
val actual = DccConfig().apply {
update(emptyMap())
}.state()
assertEquals(DccConfigState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextDccConfig()
val actual = DccConfig().apply {
update(DccConfig(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/HighlightRuleManagerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.models.QStringList
import de.justjanne.libquassel.protocol.models.rules.HighlightNickType
import de.justjanne.libquassel.protocol.models.rules.HighlightRule
import de.justjanne.libquassel.protocol.models.types.QtType
import de.justjanne.libquassel.protocol.syncables.common.HighlightRuleManager
import de.justjanne.libquassel.protocol.syncables.state.HighlightRuleManagerState
import de.justjanne.libquassel.protocol.testutil.nextEnum
import de.justjanne.libquassel.protocol.testutil.nextHighlightRule
import de.justjanne.libquassel.protocol.variant.QVariantList
import de.justjanne.libquassel.protocol.variant.QVariantMap
import de.justjanne.libquassel.protocol.variant.qVariant
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import kotlin.random.Random
class HighlightRuleManagerTest {
@Test
fun testEmpty() {
val actual = HighlightRuleManager().apply {
update(emptyMap())
}.state()
assertEquals(HighlightRuleManagerState(), actual)
}
@Test
fun testInvalidData() {
val state = HighlightRuleManagerState()
val actual = HighlightRuleManager(state = state).apply {
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"name" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isRegEx" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isCaseSensitive" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isEnabled" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isInverse" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"sender" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"HighlightRuleList" to qVariant<QVariantMap>(
mapOf(
"id" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"channel" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
}.state()
assertEquals(state, actual)
}
@Test
fun testNullData() {
val actual = HighlightRuleManager(
state = HighlightRuleManagerState()
).apply {
update(
mapOf(
"HighlightRuleList" to qVariant(
mapOf(
"id" to qVariant(
listOf(
qVariant(999, QtType.Int)
),
QtType.QVariantList
),
"name" to qVariant(
listOf(
null
),
QtType.QStringList
),
"isRegEx" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"isCaseSensitive" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"isEnabled" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"isInverse" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"sender" to qVariant(
listOf(
null
),
QtType.QStringList
),
"channel" to qVariant(
listOf(
null
),
QtType.QStringList
)
),
QtType.QVariantMap
),
"highlightNick" to qVariant(-2, QtType.Int)
)
)
}.state()
assertEquals(
HighlightRule(
id = 999,
content = "",
isRegEx = false,
isCaseSensitive = false,
isEnabled = false,
isInverse = false,
sender = "",
channel = ""
),
actual.rules.first()
)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
val actual = HighlightRuleManager(
state = HighlightRuleManagerState()
).apply {
update(HighlightRuleManager(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Nested
inner class Setters {
@Test
fun testRemoveHighlightRule() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
val rule = value.state().rules.random(random)
assertTrue(value.contains(rule.id))
assertNotEquals(-1, value.indexOf(rule.id))
value.removeHighlightRule(rule.id)
assertFalse(value.contains(rule.id))
assertEquals(-1, value.indexOf(rule.id))
}
@Test
fun testRemoveAll() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
assertFalse(value.isEmpty())
for (rule in value.state().rules) {
value.removeHighlightRule(rule.id)
}
assertTrue(value.isEmpty())
assertEquals(0, value.count())
}
@Test
fun testToggleHighlightRule() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
val rule = value.state().rules.random(random)
assertTrue(value.contains(rule.id))
assertNotEquals(-1, value.indexOf(rule.id))
assertFalse(value.state().rules[value.indexOf(rule.id)].isEnabled)
value.toggleHighlightRule(rule.id)
assertTrue(value.contains(rule.id))
assertNotEquals(-1, value.indexOf(rule.id))
assertTrue(value.state().rules[value.indexOf(rule.id)].isEnabled)
value.toggleHighlightRule(rule.id)
assertTrue(value.contains(rule.id))
assertNotEquals(-1, value.indexOf(rule.id))
assertFalse(value.state().rules[value.indexOf(rule.id)].isEnabled)
}
@Test
fun testHighlightNick() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
assertEquals(HighlightNickType.AllNicks, value.state().highlightNickType)
value.setHighlightNick(HighlightNickType.CurrentNick.value)
assertEquals(HighlightNickType.CurrentNick, value.state().highlightNickType)
value.setHighlightNick(-2)
assertEquals(HighlightNickType.CurrentNick, value.state().highlightNickType)
}
@Test
fun testNicksCaseSensitive() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
value.setNicksCaseSensitive(false)
assertEquals(false, value.state().highlightNickCaseSensitive)
value.setNicksCaseSensitive(true)
assertEquals(true, value.state().highlightNickCaseSensitive)
}
@Test
fun testAddExisting() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
val rule = value.state().rules.random(random)
val sizeBefore = value.count()
value.addHighlightRule(
id = rule.id,
content = rule.content,
isRegEx = rule.isRegEx,
isCaseSensitive = rule.isCaseSensitive,
isEnabled = rule.isEnabled,
isInverse = rule.isInverse,
sender = rule.sender,
channel = rule.channel
)
assertEquals(sizeBefore, value.count())
}
@Test
fun testAddNew() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
val rule = random.nextHighlightRule(value.count())
val sizeBefore = value.count()
value.addHighlightRule(
id = rule.id,
content = rule.content,
isRegEx = rule.isRegEx,
isCaseSensitive = rule.isCaseSensitive,
isEnabled = rule.isEnabled,
isInverse = rule.isInverse,
sender = rule.sender,
channel = rule.channel
)
assertEquals(sizeBefore + 1, value.count())
}
@Test
fun testAddEdgeCase() {
val random = Random(1337)
val value = HighlightRuleManager(
state = HighlightRuleManagerState(
rules = List(random.nextInt(20)) {
random.nextHighlightRule(it)
},
highlightNickType = random.nextEnum(),
highlightNickCaseSensitive = random.nextBoolean()
)
)
val rule = random.nextHighlightRule(value.count())
val sizeBefore = value.count()
value.addHighlightRule(
id = rule.id,
content = null,
isRegEx = rule.isRegEx,
isCaseSensitive = rule.isCaseSensitive,
isEnabled = rule.isEnabled,
isInverse = rule.isInverse,
sender = null,
channel = null
)
assertEquals(sizeBefore + 1, value.count())
}
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/IdentityTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.models.ids.IdentityId
import de.justjanne.libquassel.protocol.syncables.common.Identity
import de.justjanne.libquassel.protocol.syncables.state.IdentityState
import de.justjanne.libquassel.protocol.testutil.nextIdentity
import de.justjanne.libquassel.protocol.testutil.nextString
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import kotlin.random.Random
class IdentityTest {
@Test
fun testEmpty() {
val actual = Identity().apply {
update(emptyMap())
}.state()
assertEquals(IdentityState(), actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextIdentity()
val actual = Identity().apply {
update(Identity(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Nested
inner class Setters {
@Test
fun testNicks() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val nicks = List(random.nextInt(20)) {
random.nextString()
}
assertNotEquals(nicks, identity.nicks())
identity.setNicks(nicks)
assertEquals(nicks, identity.nicks())
}
@Test
fun testNicksInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val nick = random.nextString()
assertNotEquals(listOf(nick, ""), identity.nicks())
assertNotEquals(listOf(nick, null), identity.nicks())
identity.setNicks(listOf(nick, null))
assertEquals(listOf(nick, ""), identity.nicks())
}
@Test
fun testAutoAwayReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.autoAwayReason())
identity.setAutoAwayReason(value)
assertEquals(value, identity.autoAwayReason())
}
@Test
fun testAutoAwayReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.autoAwayReason())
assertNotEquals(null, identity.autoAwayReason())
identity.setAutoAwayReason(null)
assertEquals("", identity.autoAwayReason())
}
@Test
fun testAwayNick() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.awayNick())
identity.setAwayNick(value)
assertEquals(value, identity.awayNick())
}
@Test
fun testAwayNickInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.awayNick())
assertNotEquals(null, identity.awayNick())
identity.setAwayNick(null)
assertEquals("", identity.awayNick())
}
@Test
fun testAwayReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.awayReason())
identity.setAwayReason(value)
assertEquals(value, identity.awayReason())
}
@Test
fun testAwayReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.awayReason())
assertNotEquals(null, identity.awayReason())
identity.setAwayReason(null)
assertEquals("", identity.awayReason())
}
@Test
fun testDetachAwayReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.detachAwayReason())
identity.setDetachAwayReason(value)
assertEquals(value, identity.detachAwayReason())
}
@Test
fun testDetachAwayReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.detachAwayReason())
assertNotEquals(null, identity.detachAwayReason())
identity.setDetachAwayReason(null)
assertEquals("", identity.detachAwayReason())
}
@Test
fun testIdent() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.ident())
identity.setIdent(value)
assertEquals(value, identity.ident())
}
@Test
fun testIdentInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.ident())
assertNotEquals(null, identity.ident())
identity.setIdent(null)
assertEquals("", identity.ident())
}
@Test
fun testIdentityName() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.identityName())
identity.setIdentityName(value)
assertEquals(value, identity.identityName())
}
@Test
fun testIdentityNameInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.identityName())
assertNotEquals(null, identity.identityName())
identity.setIdentityName(null)
assertEquals("", identity.identityName())
}
@Test
fun testKickReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.kickReason())
identity.setKickReason(value)
assertEquals(value, identity.kickReason())
}
@Test
fun testKickReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.kickReason())
assertNotEquals(null, identity.kickReason())
identity.setKickReason(null)
assertEquals("", identity.kickReason())
}
@Test
fun testPartReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.partReason())
identity.setPartReason(value)
assertEquals(value, identity.partReason())
}
@Test
fun testPartReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.partReason())
assertNotEquals(null, identity.partReason())
identity.setPartReason(null)
assertEquals("", identity.partReason())
}
@Test
fun testQuitReason() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.quitReason())
identity.setQuitReason(value)
assertEquals(value, identity.quitReason())
}
@Test
fun testQuitReasonInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.quitReason())
assertNotEquals(null, identity.quitReason())
identity.setQuitReason(null)
assertEquals("", identity.quitReason())
}
@Test
fun testRealName() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextString()
assertNotEquals(value, identity.realName())
identity.setRealName(value)
assertEquals(value, identity.realName())
}
@Test
fun testRealNameInvalid() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
assertNotEquals("", identity.realName())
assertNotEquals(null, identity.realName())
identity.setRealName(null)
assertEquals("", identity.realName())
}
@Test
fun testAutoAwayEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setAutoAwayEnabled(false)
assertEquals(false, identity.autoAwayEnabled())
identity.setAutoAwayEnabled(true)
assertEquals(true, identity.autoAwayEnabled())
}
@Test
fun testAutoAwayReasonEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setAutoAwayReasonEnabled(false)
assertEquals(false, identity.autoAwayReasonEnabled())
identity.setAutoAwayReasonEnabled(true)
assertEquals(true, identity.autoAwayReasonEnabled())
}
@Test
fun testAwayNickEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setAwayNickEnabled(false)
assertEquals(false, identity.awayNickEnabled())
identity.setAwayNickEnabled(true)
assertEquals(true, identity.awayNickEnabled())
}
@Test
fun testAwayReasonEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setAwayReasonEnabled(false)
assertEquals(false, identity.awayReasonEnabled())
identity.setAwayReasonEnabled(true)
assertEquals(true, identity.awayReasonEnabled())
}
@Test
fun testDetachAwayReasonEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setDetachAwayReasonEnabled(false)
assertEquals(false, identity.detachAwayReasonEnabled())
identity.setDetachAwayReasonEnabled(true)
assertEquals(true, identity.detachAwayReasonEnabled())
}
@Test
fun testDetachAwayEnabled() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
identity.setDetachAwayEnabled(false)
assertEquals(false, identity.detachAwayEnabled())
identity.setDetachAwayEnabled(true)
assertEquals(true, identity.detachAwayEnabled())
}
@Test
fun testAutoAwayTime() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = random.nextInt()
assertNotEquals(value, identity.autoAwayTime())
identity.setAutoAwayTime(value)
assertEquals(value, identity.autoAwayTime())
}
@Test
fun testId() {
val random = Random(1337)
val identity = Identity(state = random.nextIdentity())
val value = IdentityId(random.nextInt())
assertNotEquals(value, identity.id())
identity.setId(value)
assertEquals(value, identity.id())
}
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/IgnoreListManagerTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.models.QStringList
import de.justjanne.libquassel.protocol.models.rules.IgnoreRule
import de.justjanne.libquassel.protocol.models.rules.IgnoreType
import de.justjanne.libquassel.protocol.models.rules.ScopeType
import de.justjanne.libquassel.protocol.models.rules.StrictnessType
import de.justjanne.libquassel.protocol.models.types.QtType
import de.justjanne.libquassel.protocol.syncables.common.IgnoreListManager
import de.justjanne.libquassel.protocol.syncables.state.IgnoreListManagerState
import de.justjanne.libquassel.protocol.testutil.nextIgnoreRule
import de.justjanne.libquassel.protocol.variant.QVariantList
import de.justjanne.libquassel.protocol.variant.QVariantMap
import de.justjanne.libquassel.protocol.variant.qVariant
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import kotlin.random.Random
class IgnoreListManagerTest {
@Test
fun testEmpty() {
val actual = IgnoreListManager().apply {
update(emptyMap())
}.state()
assertEquals(IgnoreListManagerState(), actual)
}
@Test
fun testInvalidData() {
val state = IgnoreListManagerState()
val actual = IgnoreListManager(state = state).apply {
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"ignoreRule" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isRegEx" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"strictness" to qVariant<QVariantList>(
listOf(
qVariant(StrictnessType.SoftStrictness.value, QtType.Int)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"isActive" to qVariant<QVariantList>(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"scope" to qVariant<QVariantList>(
listOf(
qVariant(ScopeType.GlobalScope.value, QtType.Int)
),
QtType.QVariantList
),
),
QtType.QVariantMap
)
)
)
}
assertThrows<IllegalArgumentException> {
update(
mapOf(
"IgnoreList" to qVariant<QVariantMap>(
mapOf(
"ignoreType" to qVariant<QVariantList>(emptyList(), QtType.QVariantList),
"scopeRule" to qVariant<QStringList>(listOf(""), QtType.QStringList),
),
QtType.QVariantMap
)
)
)
}
}.state()
assertEquals(state, actual)
}
@Test
fun testNulLData() {
val actual = IgnoreListManager(
state = IgnoreListManagerState()
).apply {
update(
mapOf(
"IgnoreList" to qVariant(
mapOf(
"ignoreType" to qVariant(
listOf(
qVariant(-2, QtType.Int)
),
QtType.QVariantList
),
"ignoreRule" to qVariant(
listOf(null),
QtType.QStringList
),
"isRegEx" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"strictness" to qVariant(
listOf(
qVariant(-2, QtType.Int)
),
QtType.QVariantList
),
"isActive" to qVariant(
listOf(
qVariant(false, QtType.Bool)
),
QtType.QVariantList
),
"scope" to qVariant(
listOf(
qVariant(-2, QtType.Int)
),
QtType.QVariantList
),
"scopeRule" to qVariant(
listOf(
null
),
QtType.QStringList
)
),
QtType.QVariantMap
)
)
)
}.state()
assertEquals(
IgnoreRule(
type = IgnoreType.SenderIgnore,
ignoreRule = "",
isRegEx = false,
strictness = StrictnessType.UnmatchedStrictness,
isEnabled = false,
scope = ScopeType.GlobalScope,
scopeRule = ""
),
actual.rules.first()
)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
val actual = IgnoreListManager(
state = IgnoreListManagerState()
).apply {
update(IgnoreListManager(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Nested
inner class Setters {
@Test
fun testRemoveIgnoreRule() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = value.state().rules.random(random)
assertTrue(value.contains(rule.ignoreRule))
assertNotEquals(-1, value.indexOf(rule.ignoreRule))
value.removeIgnoreListItem(rule.ignoreRule)
assertFalse(value.contains(rule.ignoreRule))
assertEquals(-1, value.indexOf(rule.ignoreRule))
}
@Test
fun testRemoveAll() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
assertFalse(value.isEmpty())
for (rule in value.state().rules) {
value.removeIgnoreListItem(rule.ignoreRule)
}
assertTrue(value.isEmpty())
assertEquals(0, value.count())
}
@Test
fun testToggleHighlightRule() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = value.state().rules.random(random)
assertTrue(value.contains(rule.ignoreRule))
assertNotEquals(-1, value.indexOf(rule.ignoreRule))
assertTrue(value.state().rules[value.indexOf(rule.ignoreRule)].isEnabled)
value.toggleIgnoreRule(rule.ignoreRule)
assertTrue(value.contains(rule.ignoreRule))
assertNotEquals(-1, value.indexOf(rule.ignoreRule))
assertFalse(value.state().rules[value.indexOf(rule.ignoreRule)].isEnabled)
value.toggleIgnoreRule(rule.ignoreRule)
assertTrue(value.contains(rule.ignoreRule))
assertNotEquals(-1, value.indexOf(rule.ignoreRule))
assertTrue(value.state().rules[value.indexOf(rule.ignoreRule)].isEnabled)
}
@Test
fun testAddExisting() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = value.state().rules.random(random)
val sizeBefore = value.count()
value.addIgnoreListItem(
type = rule.type.value,
ignoreRule = rule.ignoreRule,
isRegEx = rule.isRegEx,
strictness = rule.strictness.value,
scope = rule.scope.value,
scopeRule = rule.scopeRule,
isActive = rule.isEnabled
)
assertEquals(sizeBefore, value.count())
}
@Test
fun testAddNew() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = random.nextIgnoreRule()
val sizeBefore = value.count()
value.addIgnoreListItem(
type = rule.type.value,
ignoreRule = rule.ignoreRule,
isRegEx = rule.isRegEx,
strictness = rule.strictness.value,
scope = rule.scope.value,
scopeRule = rule.scopeRule,
isActive = rule.isEnabled
)
assertEquals(sizeBefore + 1, value.count())
}
@Test
fun testAddEdgeCase() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = random.nextIgnoreRule()
val sizeBefore = value.count()
value.addIgnoreListItem(
type = rule.type.value,
ignoreRule = null,
isRegEx = rule.isRegEx,
strictness = rule.strictness.value,
scope = rule.scope.value,
scopeRule = null,
isActive = rule.isEnabled
)
assertEquals(sizeBefore + 1, value.count())
}
@Test
fun testAddEdgeCaseUnchanged() {
val random = Random(1337)
val value = IgnoreListManager(
state = IgnoreListManagerState(
rules = List(random.nextInt(20)) {
random.nextIgnoreRule()
}
)
)
val rule = random.nextIgnoreRule()
val sizeBefore = value.count()
value.addIgnoreListItem(
type = -2,
ignoreRule = null,
isRegEx = rule.isRegEx,
strictness = rule.strictness.value,
scope = rule.scope.value,
scopeRule = null,
isActive = rule.isEnabled
)
assertEquals(sizeBefore, value.count())
value.addIgnoreListItem(
type = rule.type.value,
ignoreRule = null,
isRegEx = rule.isRegEx,
strictness = -2,
scope = rule.scope.value,
scopeRule = null,
isActive = rule.isEnabled
)
assertEquals(sizeBefore, value.count())
value.addIgnoreListItem(
type = rule.type.value,
ignoreRule = null,
isRegEx = rule.isRegEx,
strictness = rule.strictness.value,
scope = -2,
scopeRule = null,
isActive = rule.isEnabled
)
assertEquals(sizeBefore, value.count())
}
}
}
libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/IrcChannelTest.kt deleted 100644 → 0
View file @ 05997cd2
/*
* libquassel
* Copyright (c) 2021 Janne Mareike Koschinski
*
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at https://mozilla.org/MPL/2.0/.
*/
package de.justjanne.libquassel.protocol.syncables
import de.justjanne.libquassel.protocol.models.ids.NetworkId
import de.justjanne.libquassel.protocol.models.network.ChannelModes
import de.justjanne.libquassel.protocol.syncables.common.IrcChannel
import de.justjanne.libquassel.protocol.syncables.common.IrcUser
import de.justjanne.libquassel.protocol.syncables.common.Network
import de.justjanne.libquassel.protocol.syncables.state.IrcChannelState
import de.justjanne.libquassel.protocol.testutil.mocks.EmptySession
import de.justjanne.libquassel.protocol.testutil.nextIrcChannel
import de.justjanne.libquassel.protocol.testutil.nextNetwork
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import kotlin.random.Random
class IrcChannelTest {
@Test
fun testEmpty() {
val state = IrcChannelState(
network = NetworkId(1),
name = "#name"
)
val actual = IrcChannel(state = state).apply {
update(emptyMap())
}.state()
assertEquals(state, actual)
}
@Test
fun testSerialization() {
val random = Random(1337)
val expected = random.nextIrcChannel(NetworkId(random.nextInt()))
val actual = IrcChannel(
state = IrcChannelState(
network = expected.network,
name = expected.name,
)
).apply {
update(IrcChannel(state = expected).toVariantMap())
}.state()
assertEquals(expected, actual)
}
@Nested
inner class Setters {
@Test
fun testTopic() {
val random = Random(1337)
val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
assertNotEquals("IMPLEMENTATION DEFINED CONTROVERSY", channel.topic())
channel.setTopic("IMPLEMENTATION DEFINED CONTROVERSY")
assertEquals("IMPLEMENTATION DEFINED CONTROVERSY", channel.topic())
}
@Test
fun testPassword() {
val random = Random(1337)
val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
assertNotEquals("hunter2", channel.password())
channel.setPassword("hunter2")
assertEquals("hunter2", channel.password())
}
@Test
fun testEncrypted() {
val random = Random(1337)
val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
channel.setEncrypted(false)
assertEquals(false, channel.isEncrypted())
channel.setEncrypted(true)
assertEquals(true, channel.isEncrypted())
}
}
@Nested
inner class AddChannelMode {
@Test
fun noSession() {
val random = Random(1337)
val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
val channelModes = channel.state().channelModes
channel.addChannelMode('a', value = "*!*@*")
assertEquals(channelModes, channel.state().channelModes)
}
@Test
fun chanmodeUnknown() {
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(session, it.value.state())
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('e', value = "*!*@*")
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
}
@Test
fun chanmodeA() {
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(session, it.value.state())
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('a', value = "*!*@*")
assertEquals(
mapOf(
'a' to setOf("*!*@*")
),
channel.state().channelModes.a
)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('a', value = "user!ident@host")
assertEquals(
mapOf(
'a' to setOf("*!*@*", "user!ident@host")
),
channel.state().channelModes.a
)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
assertThrows(IllegalArgumentException::class.java) {
channel.addChannelMode('a', value = null)
}
}
@Test
fun chanmodeB() {
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(session, it.value.state())
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('b', value = "*!*@*")
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(
mapOf(
'b' to "*!*@*"
),
channel.state().channelModes.b
)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
assertThrows(IllegalArgumentException::class.java) {
channel.addChannelMode('b', value = null)
}
}
@Test
fun chanmodeC() {
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(session, it.value.state())
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('c', value = "*!*@*")
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(
mapOf(
'c' to "*!*@*"
),
channel.state().channelModes.c
)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
assertThrows(IllegalArgumentException::class.java) {
channel.addChannelMode('c', value = null)
}
}
@Test
fun chanmodeD() {
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(session, it.value.state())
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
channel.addChannelMode('d', value = "*!*@*")
assertEquals(emptyMap<Char, Set<String>>(), channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(setOf('d'), channel.state().channelModes.d)
}
}
@Nested
inner class RemoveChannelMode {
@Test
fun noSession() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2"),
'A' to setOf("A1", "A2")
),
b = mapOf(
'b' to "b1",
'B' to "B1"
),
c = mapOf(
'c' to "c1",
'C' to "C1"
),
d = setOf('d', 'D')
)
val random = Random(1337)
val channel = IrcChannel(
state = random.nextIrcChannel(NetworkId(random.nextInt()))
.copy(channelModes = expected)
)
channel.removeChannelMode('a', value = "a1")
assertEquals(expected, channel.state().channelModes)
}
@Test
fun chanmodeUnknown() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2"),
'A' to setOf("A1", "A2")
),
b = mapOf(
'b' to "b1",
'B' to "B1"
),
c = mapOf(
'c' to "c1",
'C' to "C1"
),
d = setOf('d', 'D')
)
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "a,b,c,d"
),
ircChannels = ircChannels.mapValues {
IrcChannel(
session,
it.value.state()
.copy(channelModes = expected)
)
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
channel.removeChannelMode('e', value = "*!*@*")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
}
@Test
fun chanmodeA() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2")
),
b = mapOf(
'b' to "b1"
),
c = mapOf(
'c' to "c1"
),
d = setOf('d')
)
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "aA,bB,cC,dD"
),
ircChannels = ircChannels.mapValues {
IrcChannel(
session,
it.value.state()
.copy(channelModes = expected)
)
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('A'))
assertTrue(channel.hasMode('a'))
assertEquals(emptySet<String>(), channel.modeValues('A'))
assertEquals(setOf("a1", "a2"), channel.modeValues('a'))
channel.removeChannelMode('A', value = "a1")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('A'))
assertTrue(channel.hasMode('a'))
assertEquals(emptySet<String>(), channel.modeValues('A'))
assertEquals(setOf("a1", "a2"), channel.modeValues('a'))
channel.removeChannelMode('a', value = "a1")
assertEquals(
mapOf(
'a' to setOf("a2"),
),
channel.state().channelModes.a
)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('A'))
assertTrue(channel.hasMode('a'))
assertEquals(emptySet<String>(), channel.modeValues('A'))
assertEquals(setOf("a2"), channel.modeValues('a'))
channel.removeChannelMode('a', value = "a1")
assertEquals(
mapOf(
'a' to setOf("a2"),
),
channel.state().channelModes.a
)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('A'))
assertTrue(channel.hasMode('a'))
assertEquals(emptySet<String>(), channel.modeValues('A'))
assertEquals(setOf("a2"), channel.modeValues('a'))
assertThrows(IllegalArgumentException::class.java) {
channel.removeChannelMode('a', value = null)
}
}
@Test
fun chanmodeB() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2")
),
b = mapOf(
'b' to "b1"
),
c = mapOf(
'c' to "c1"
),
d = setOf('d')
)
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "aA,bB,cC,dD"
),
ircChannels = ircChannels.mapValues {
IrcChannel(
session,
it.value.state()
.copy(channelModes = expected)
)
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('B'))
assertTrue(channel.hasMode('b'))
channel.removeChannelMode('B', value = "b1")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('B'))
assertTrue(channel.hasMode('b'))
channel.removeChannelMode('b', value = "b1")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('B'))
assertFalse(channel.hasMode('b'))
channel.removeChannelMode('b', value = "b2")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('B'))
assertFalse(channel.hasMode('b'))
}
@Test
fun chanmodeC() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2")
),
b = mapOf(
'b' to "b1"
),
c = mapOf(
'c' to "c1"
),
d = setOf('d')
)
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "aA,bB,cC,dD"
),
ircChannels = ircChannels.mapValues {
IrcChannel(
session,
it.value.state()
.copy(channelModes = expected)
)
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('C'))
assertTrue(channel.hasMode('c'))
assertEquals("", channel.modeValue('C'))
assertEquals("c1", channel.modeValue('c'))
channel.removeChannelMode('C', value = "c1")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('C'))
assertTrue(channel.hasMode('c'))
assertEquals("", channel.modeValue('C'))
assertEquals("c1", channel.modeValue('c'))
channel.removeChannelMode('c', value = "c1")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('C'))
assertFalse(channel.hasMode('c'))
assertEquals("", channel.modeValue('C'))
assertEquals("", channel.modeValue('c'))
channel.removeChannelMode('c', value = "c2")
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(emptyMap<Char, String>(), channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('C'))
assertFalse(channel.hasMode('c'))
assertEquals("", channel.modeValue('C'))
assertEquals("", channel.modeValue('c'))
}
@Test
fun chanmodeD() {
val expected = ChannelModes(
a = mapOf(
'a' to setOf("a1", "a2")
),
b = mapOf(
'b' to "b1"
),
c = mapOf(
'c' to "c1"
),
d = setOf('d')
)
val random = Random(1337)
val session = ChannelMockSession()
val network = Network(
session,
state = random.nextNetwork(NetworkId(random.nextInt())).run {
copy(
supports = mapOf(
"CHANMODES" to "aA,bB,cC,dD"
),
ircChannels = ircChannels.mapValues {
IrcChannel(
session,
it.value.state()
.copy(channelModes = expected)
)
},
ircUsers = ircUsers.mapValues {
IrcUser(session, it.value.state())
}
)
}
)
session.networks.add(network)
val channel = network.state().ircChannels.values.first()
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('D'))
assertTrue(channel.hasMode('d'))
channel.removeChannelMode('D')
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertEquals(expected.d, channel.state().channelModes.d)
assertFalse(channel.hasMode('D'))
assertTrue(channel.hasMode('d'))
channel.removeChannelMode('d')
assertEquals(expected.a, channel.state().channelModes.a)
assertEquals(expected.b, channel.state().channelModes.b)
assertEquals(expected.c, channel.state().channelModes.c)
assertFalse(channel.hasMode('D'))
assertFalse(channel.hasMode('d'))
assertEquals(emptySet<Char>(), channel.state().channelModes.d)
}
}
class ChannelMockSession : EmptySession() {
val networks = mutableListOf<Network>()
override fun network(id: NetworkId) = networks.find { it.networkId() == id }
}
}