Add names handling and channel users

src/main/kotlin/com/dmdirc/ktirc/events/ChannelStateHandler.kt

@@ -2,6 +2,8 @@ package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.model.ChannelState
+import com.dmdirc.ktirc.model.ChannelUser
+import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.util.logger
 
 class ChannelStateHandler : EventHandler {
@@ -11,15 +13,42 @@ class ChannelStateHandler : EventHandler {
     override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ChannelJoined -> handleJoin(client, event)
+            is ChannelNamesReceived -> handleNamesReceived(client, event)
+            is ChannelNamesFinished -> handleNamesFinished(client, event)
         }
     }
 
     private fun handleJoin(client: IrcClient, event: ChannelJoined) {
         if (client.isLocalUser(event.user)) {
             log.info { "Joined new channel: ${event.channel}" }
-            client.channelState += ChannelState(event.channel)
+            client.channelState += ChannelState(event.channel) { client.caseMapping }
+        }
+
+        client.channelState[event.channel]?.let { it.users += ChannelUser(event.user.nickname) }
+    }
+
+    private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
+        val channel = client.channelState[event.channel] ?: return
+
+        if (!channel.receivingUserList) {
+            log.finer { "Started receiving names list for ${channel.name}" }
+            channel.users.clear()
+            channel.receivingUserList = true
+        }
+
+        val modePrefixes = client.serverState.features[ServerFeature.ModePrefixes]!!
+        for (user in event.names) {
+            user.takeWhile { modePrefixes.isPrefix(it) }.let { prefix ->
+                channel.users += ChannelUser(user.substring(prefix.length), modePrefixes.getModes(prefix))
+            }
+        }
+    }
+
+    private fun handleNamesFinished(client: IrcClient, event: ChannelNamesFinished) {
+        client.channelState[event.channel]?.let {
+            it.receivingUserList = false
+            log.finest { "Finished receiving names in ${event.channel}. Users: ${it.users.toList()}" }
         }
-        // TODO: Add user to channel
     }
 
 }

src/main/kotlin/com/dmdirc/ktirc/events/EventHandler.kt

@@ -9,6 +9,7 @@ interface EventHandler {
 }
 
 val eventHandlers = setOf(
+        ChannelStateHandler(),
         PingHandler(),
         ServerStateHandler()
 )

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

@@ -7,28 +7,24 @@ import com.dmdirc.ktirc.model.User
 
 sealed class IrcEvent
 
-/**
- * Raised when the server initially welcomes us to the IRC network.
- */
-data class ServerWelcome(val localNick: String): IrcEvent()
-
-/**
- * Raised when the features supported by the server have changed. This may occur numerous times during the
- * connection phase.
- */
+/** Raised when the server initially welcomes us to the IRC network. */
+data class ServerWelcome(val localNick: String) : IrcEvent()
+
+/** Raised when the features supported by the server have changed. This may occur numerous times. */
 data class ServerFeaturesUpdated(val serverFeatures: ServerFeatureMap) : IrcEvent()
 
-/**
- * Raised when the connection to the server has been established, configuration information has been received, etc.
- */
+/** Raised when the connection to the server has been established, configuration information has been received, etc. */
+// TODO: Implement
 object ServerConnected : IrcEvent()
 
-/**
- * Raised whenever a PING is received from the server.
- */
-data class PingReceived(val nonce: ByteArray): IrcEvent()
+/** Raised whenever a PING is received from the server. */
+data class PingReceived(val nonce: ByteArray) : IrcEvent()
+
+/** Raised when a user joins a channel. */
+data class ChannelJoined(val user: User, val channel: String) : IrcEvent()
+
+/** Raised when a batch of the channel's member list has been received. More batches may follow. */
+data class ChannelNamesReceived(val channel: String, val names: List<String>) : IrcEvent()
 
-/**
- * Raised when a user joins a channel.
- */
-data class ChannelJoined(val user: User, val channel: String): IrcEvent()
+/** Raised when the entirety of the channel's member list has been received. */
+data class ChannelNamesFinished(val channel: String) : IrcEvent()

src/main/kotlin/com/dmdirc/ktirc/messages/ISupportProcessor.kt

@@ -3,6 +3,7 @@ package com.dmdirc.ktirc.messages
 import com.dmdirc.ktirc.events.ServerFeaturesUpdated
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.serverFeatures
 import com.dmdirc.ktirc.util.logger
@@ -57,11 +58,14 @@ class ISupportProcessor : MessageProcessor {
                 null
             }
 
-    private fun ByteArray.cast(to: KClass<out Any>): Any = when (to) {
-        Int::class -> String(this).toInt()
-        String::class -> String(this)
-        CaseMapping::class -> CaseMapping.fromName(String(this))
-        else -> TODO("not implemented")
+    private fun ByteArray.cast(to: KClass<out Any>): Any = with (String(this)) {
+        when (to) {
+            Int::class -> toInt()
+            String::class -> this
+            CaseMapping::class -> CaseMapping.fromName(this)
+            ModePrefixMapping::class -> indexOf(')').let { ModePrefixMapping(substring(1 until it), substring(it + 1)) }
+            else -> TODO("not implemented")
+        }
     }
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/MessageProcessor.kt

@@ -20,6 +20,7 @@ interface MessageProcessor {
 val messageProcessors = setOf(
         ISupportProcessor(),
         JoinProcessor(),
+        NamesProcessor(),
         PingProcessor(),
         WelcomeProcessor()
 )

src/main/kotlin/com/dmdirc/ktirc/messages/NamesProcessor.kt

@@ -0,0 +1,17 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ChannelNamesFinished
+import com.dmdirc.ktirc.events.ChannelNamesReceived
+import com.dmdirc.ktirc.io.IrcMessage
+
+class NamesProcessor : MessageProcessor {
+
+    override val commands = arrayOf("353", "366")
+
+    override fun process(message: IrcMessage) = when (message.command) {
+        "353" -> listOf(ChannelNamesReceived(String(message.params[2]), String(message.params[3]).split(' ')))
+        "366" -> listOf(ChannelNamesFinished(String(message.params[1])))
+        else -> emptyList()
+    }
+
+}

src/main/kotlin/com/dmdirc/ktirc/model/ChannelState.kt

@@ -1,3 +1,12 @@
 package com.dmdirc.ktirc.model
 
-class ChannelState(val name: String)
+import com.dmdirc.ktirc.io.CaseMapping
+
+class ChannelState(val name: String, caseMappingProvider: () -> CaseMapping) {
+
+    var receivingUserList = false
+    val users = ChannelUserMap(caseMappingProvider)
+
+}
+
+data class ChannelUser(var nickname: String, var modes: String = "")

src/main/kotlin/com/dmdirc/ktirc/model/ChannelStateMap.kt

@@ -1,24 +0,0 @@
-package com.dmdirc.ktirc.model
-
-import com.dmdirc.ktirc.io.CaseMapping
-
-class ChannelStateMap(private val caseMappingProvider: () -> CaseMapping) : Iterable<ChannelState> {
-
-    private val channels = HashSet<ChannelState>()
-
-    operator fun get(name: String) = channels.find { caseMappingProvider().areEquivalent(it.name, name) }
-
-    operator fun plusAssign(state: ChannelState) {
-        require(get(state.name) == null) { "Channel state already registered: ${state.name}"}
-        channels.add(state)
-    }
-
-    operator fun minusAssign(state: ChannelState) {
-        channels.removeIf { caseMappingProvider().areEquivalent(it.name, state.name) }
-    }
-
-    operator fun contains(name: String) = get(name) != null
-
-    override fun iterator() = channels.iterator()
-
-}

src/main/kotlin/com/dmdirc/ktirc/model/Maps.kt

@@ -0,0 +1,29 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+
+abstract class CaseInsensitiveMap<T>(private val caseMappingProvider: () -> CaseMapping, private val nameOf: (T) -> String) : Iterable<T> {
+
+    private val values = HashSet<T>()
+
+    operator fun get(name: String) = values.find { caseMappingProvider().areEquivalent(nameOf(it), name) }
+
+    operator fun plusAssign(value: T) {
+        require(get(nameOf(value)) == null) { "Value already registered: ${nameOf(value)}"}
+        values.add(value)
+    }
+
+    operator fun minusAssign(state: T) {
+        values.removeIf { caseMappingProvider().areEquivalent(nameOf(it), nameOf(state)) }
+    }
+
+    operator fun contains(name: String) = get(name) != null
+
+    override fun iterator() = values.iterator()
+
+    fun clear() = values.clear()
+
+}
+
+class ChannelStateMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<ChannelState>(caseMappingProvider, ChannelState::name)
+class ChannelUserMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<ChannelUser>(caseMappingProvider, ChannelUser::nickname)

src/main/kotlin/com/dmdirc/ktirc/model/ServerState.kt

@@ -27,8 +27,17 @@ class ServerFeatureMap {
 
 }
 
+data class ModePrefixMapping(val modes: String, val prefixes: String) {
+
+    fun isPrefix(char: Char) = prefixes.contains(char)
+    fun getMode(prefix: Char) = modes[prefixes.indexOf(prefix)]
+    fun getModes(prefixes: String) = String(prefixes.map(this::getMode).toCharArray())
+
+}
+
 sealed class ServerFeature<T : Any>(val name: String, val type: KClass<T>, val default: T? = null) {
     object ServerCaseMapping : ServerFeature<CaseMapping>("CASEMAPPING", CaseMapping::class, CaseMapping.Rfc)
+    object ModePrefixes : ServerFeature<ModePrefixMapping>("PREFIX", ModePrefixMapping::class, ModePrefixMapping("ov", "@+"))
     object MaximumChannels : ServerFeature<Int>("CHANLIMIT", Int::class)
     object ChannelModes : ServerFeature<String>("CHANMODES", String::class)
     object MaximumChannelNameLength : ServerFeature<Int>("CHANNELLEN", Int::class, 200)

src/test/kotlin/com/dmdirc/ktirc/events/ChannelStateHandlerTest.kt

@@ -2,35 +2,102 @@ package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.io.CaseMapping
-import com.dmdirc.ktirc.model.ChannelStateMap
-import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
 import kotlinx.coroutines.runBlocking
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ChannelStateHandlerTest {
 
+    private val handler = ChannelStateHandler()
     private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+    private val serverState = ServerState("")
     private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
         on { channelState } doReturn channelStateMap
         on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
     }
 
     @Test
     fun `ChannelStateHandler creates new state object for local joins`() = runBlocking {
-        val handler = ChannelStateHandler()
-        handler.processEvent(ircClient, ChannelJoined(User("acidburn", "libby", "root.localhost"), "#newchannel"))
-        assertTrue("#newchannel" in channelStateMap)
+        handler.processEvent(ircClient, ChannelJoined(User("acidburn", "libby", "root.localhost"), "#thegibson"))
+        assertTrue("#thegibson" in channelStateMap)
     }
 
     @Test
     fun `ChannelStateHandler does not create new state object for remote joins`() = runBlocking {
-        val handler = ChannelStateHandler()
-        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#newchannel"))
-        assertFalse("#newchannel" in channelStateMap)
+        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        assertFalse("#thegibson" in channelStateMap)
+    }
+
+    @Test
+    fun `ChannelStateHandler adds joiners to channel state`() = runBlocking {
+        channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
+
+        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+
+        assertTrue("zerocool" in channelStateMap["#thegibson"]?.users!!)
+    }
+
+    @Test
+    fun `ChannelStateHandler clears existing users when getting a new list`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channel.users += ChannelUser("acidBurn")
+        channel.users += ChannelUser("thePlague")
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
+
+        assertEquals(1, channel.users.count())
+        assertNotNull(channel.users["zeroCool"])
+    }
+
+    @Test
+    fun `ChannelStateHandler adds users from multiple name received events`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("thePlague")))
+
+        assertEquals(3, channel.users.count())
+        assertNotNull(channel.users["zeroCool"])
+        assertNotNull(channel.users["acidBurn"])
+        assertNotNull(channel.users["thePlague"])
+    }
+
+    @Test
+    fun `ChannelStateHandler clears and readds users on additional names received`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesFinished("#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("thePlague")))
+
+        assertEquals(2, channel.users.count())
+        assertNotNull(channel.users["acidBurn"])
+        assertNotNull(channel.users["thePlague"])
+    }
+
+    @Test
+    fun `ChannelStateHandler adds users with mode prefixes`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+
+        handler.processEvent(ircClient, ChannelNamesReceived("#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
+        handler.processEvent(ircClient, ChannelNamesFinished("#thegibson"))
+
+        assertEquals(4, channel.users.count())
+        assertEquals("o", channel.users["zeroCool"]?.modes)
+        assertEquals("ov", channel.users["acidBurn"]?.modes)
+        assertEquals("v", channel.users["thePlague"]?.modes)
+        assertEquals("", channel.users["cerealKiller"]?.modes)
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/messages/ISupportProcessorTest.kt

@@ -2,6 +2,7 @@ package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import org.junit.jupiter.api.Assertions.*
@@ -52,6 +53,14 @@ internal class ISupportProcessorTest {
         assertEquals(CaseMapping.RfcStrict, events[0].serverFeatures[ServerFeature.ServerCaseMapping])
     }
 
+    @Test
+    fun `ISupportProcessor handles mode prefix arguments`() {
+        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+                listOf("nickname", "PREFIX=(ovd)@+%", "are supported blah blah").map { it.toByteArray() }))
+
+        assertEquals(ModePrefixMapping("ovd", "@+%"), events[0].serverFeatures[ServerFeature.ModePrefixes])
+    }
+
     @Test
     fun `ISupportProcessor handles boolean features with no arguments`() {
         val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",

src/test/kotlin/com/dmdirc/ktirc/messages/NamesProcessorTest.kt

@@ -0,0 +1,31 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ChannelNamesFinished
+import com.dmdirc.ktirc.events.ChannelNamesReceived
+import com.dmdirc.ktirc.io.IrcMessage
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class NamesProcessorTest {
+
+    private val processor = NamesProcessor()
+
+    @Test
+    fun `NamesProcessor handles end of names reply`() {
+        val events = processor.process(IrcMessage(null, ":the.gibson".toByteArray(), "366", listOf("AcidBurn", "#root", "End of /NAMES list").map { it.toByteArray() }))
+
+        assertEquals(1, events.size)
+        assertEquals("#root", (events[0] as ChannelNamesFinished).channel)
+    }
+
+    @Test
+    fun `NamesProcessor handles names reply`() {
+        val events = processor.process(IrcMessage(null, ":the.gibson".toByteArray(), "353", listOf("AcidBurn", "@", "#root", "AcidBurn @ZeroCool +ThePlague").map { it.toByteArray() }))
+
+        assertEquals(1, events.size)
+        val event = events[0] as ChannelNamesReceived
+        assertEquals("#root", event.channel)
+        assertEquals(listOf("AcidBurn", "@ZeroCool", "+ThePlague"), event.names)
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/model/ChannelStateMapTest.kt

@@ -1,78 +0,0 @@
-package com.dmdirc.ktirc.model
-
-import com.dmdirc.ktirc.io.CaseMapping
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-
-internal class ChannelStateMapTest {
-
-    @Test
-    fun `ChannelStateMap stores channel state`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        val channelState = ChannelState("#dumpsterdiving")
-        channelStateMap += channelState
-
-        assertSame(channelState, channelStateMap["#dumpsterdiving"])
-    }
-
-    @Test
-    fun `ChannelStateMap disallows setting the same channel twice`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        channelStateMap += ChannelState("#dumpsterdiving")
-
-        assertThrows<IllegalArgumentException> {
-            channelStateMap += ChannelState("#DumpsterDiving")
-        }
-    }
-
-    @Test
-    fun `ChannelStateMap retrieves channels in different cases`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        val channelState = ChannelState("#dumpsterdiving[]")
-        channelStateMap += channelState
-
-        assertSame(channelState, channelStateMap["#dumpsterdiving{}"])
-    }
-
-    @Test
-    fun `ChannelStateMap returns null if channel not found`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Ascii }
-        val channelState = ChannelState("#dumpsterdiving[]")
-        channelStateMap += channelState
-
-        assertNull(channelStateMap["#dumpsterdiving{}"])
-    }
-
-    @Test
-    fun `ChannelStateMap removes channels`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        val channelState = ChannelState("#dumpsterdiving")
-        channelStateMap += channelState
-        channelStateMap -= ChannelState("#dumpsterDIVING")
-
-        assertNull(channelStateMap["#dumpsterdiving"])
-    }
-
-    @Test
-    fun `ChannelStateMap can be iterated`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        channelStateMap += ChannelState("#dumpsterdiving")
-        channelStateMap += ChannelState("#gibson")
-
-        val names = channelStateMap.map { it.name }.toList()
-        assertEquals(2, names.size)
-        assertTrue(names.contains("#dumpsterdiving"))
-        assertTrue(names.contains("#gibson"))
-    }
-
-    @Test
-    fun `ChannelStateMap indicates if it contains a channel or not`() {
-        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
-        channelStateMap += ChannelState("#dumpsterdiving")
-
-        assertTrue("#dumpsterDIVING" in channelStateMap)
-        assertFalse("#crashandburn" in channelStateMap)
-    }
-
-}

src/test/kotlin/com/dmdirc/ktirc/model/MapsTest.kt

@@ -0,0 +1,127 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+internal class CaseInsensitiveMapTest {
+
+    private var caseMapping = CaseMapping.Rfc
+    private val map = object : CaseInsensitiveMap<String>({ caseMapping }, { str -> str.substring(0, 4) }) {}
+
+    @Test
+    fun `CaseInsensitiveMap stores values`() {
+        val value = "acidBurn"
+
+        map += value
+
+        assertSame(value, map["acid"])
+    }
+
+    @Test
+    fun `CaseInsensitiveMap disallows the same value twice`() {
+        val value = "acidBurn"
+
+        map += value
+
+        assertThrows<IllegalArgumentException> {
+            map += value
+        }
+    }
+
+    @Test
+    fun `CaseInsensitiveMap retrieves values using differently cased keys`() {
+        val value = "[acidBurn]"
+        map += value
+
+        assertSame(value, map["{ACI"])
+    }
+
+    @Test
+    fun `CaseInsensitiveMap retrieves values if the casemapping changes`() {
+        val value = "[acidBurn]"
+        map += value
+
+        caseMapping = CaseMapping.Ascii
+
+        assertSame(value, map["[ACI"])
+        assertNull(map["{aci"])
+    }
+
+    @Test
+    fun `CaseInsensitiveMap retrieves null if value not found`() {
+        val value = "[acidBurn]"
+        map += value
+
+        assertNull(map["acidBurn"])
+        assertNull(map["thePlague"])
+    }
+
+    @Test
+    fun `CaseInsensitiveMap removes values`() {
+        map += "acidBurn"
+        map -= "ACIDburn"
+
+        assertNull(map["acidBurn"])
+        assertNull(map["ACIDburn"])
+    }
+
+    @Test
+    fun `CaseInsensitiveMap can be iterated`() {
+        map += "acidBurn"
+        map += "zeroCool"
+
+        val names = map.toList()
+        assertEquals(2, names.size)
+        assertTrue(names.contains("acidBurn"))
+        assertTrue(names.contains("zeroCool"))
+    }
+
+    @Test
+    fun `ChannelInsensitiveMap indicates if it contains a value or not`() {
+        map += "acidBurn"
+
+        assertTrue("acid" in map)
+        assertFalse("theP" in map)
+    }
+
+    @Test
+    fun `ChannelInsensitiveMap can be cleared`() {
+        map += "acidBurn"
+        map += "zeroCool"
+
+        map.clear()
+
+        assertFalse("acid" in map)
+        assertFalse("zero" in map)
+        assertEquals(0, map.count())
+    }
+
+}
+
+internal class ChannelStateMapTest {
+
+    @Test
+    fun `ChannelStateMap maps channels on name`() {
+        val channelUserMap = ChannelStateMap { CaseMapping.Rfc }
+        channelUserMap += ChannelState("#dumpsterDiving") { CaseMapping.Rfc }
+        assertTrue("#dumpsterDiving" in channelUserMap)
+        assertTrue("#dumpsterdiving" in channelUserMap)
+        assertFalse("#thegibson" in channelUserMap)
+    }
+
+}
+
+internal class ChannelUserMapTest {
+
+    @Test
+    fun `ChannelUserMap maps users on nickname`() {
+        val channelUserMap = ChannelUserMap { CaseMapping.Rfc }
+        channelUserMap += ChannelUser("acidBurn")
+        assertTrue("acidBurn" in channelUserMap)
+        assertTrue("acidburn" in channelUserMap)
+        assertFalse("zerocool" in channelUserMap)
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/model/ServerStateTest.kt

@@ -1,6 +1,6 @@
 package com.dmdirc.ktirc.model
 
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ServerStateTest {
@@ -11,4 +11,34 @@ internal class ServerStateTest {
         assertEquals("acidBurn", serverState.localNickname)
     }
 
+}
+
+internal class ModePrefixMappingTest {
+
+    @Test
+    fun `ModePrefixMapping identifies which chars are prefixes`() {
+        val mapping = ModePrefixMapping("oav", "+@-")
+        assertTrue(mapping.isPrefix('+'))
+        assertTrue(mapping.isPrefix('@'))
+        assertFalse(mapping.isPrefix('!'))
+        assertFalse(mapping.isPrefix('o'))
+    }
+
+    @Test
+    fun `ModePrefixMapping maps prefixes to modes`() {
+        val mapping = ModePrefixMapping("oav", "+@-")
+        assertEquals('o', mapping.getMode('+'))
+        assertEquals('a', mapping.getMode('@'))
+        assertEquals('v', mapping.getMode('-'))
+    }
+
+    @Test
+    fun `ModePrefixMapping maps prefix strings to modes`() {
+        val mapping = ModePrefixMapping("oav", "+@-")
+        assertEquals("oa", mapping.getModes("+@"))
+        assertEquals("o", mapping.getModes("+"))
+        assertEquals("", mapping.getModes(""))
+        assertEquals("vao", mapping.getModes("-@+"))
+    }
+
 }