Handle mode events

Move numerics into constants
Tidy up how IrcMessage params are made in tests

CHANGELOG

 vNEXT (in development)
 
- * Added MotdFinished event
- * Added UserAccountChanged event
+ * Server state:
+    * Added ServerConnecting and ServerDisconnected events
+    * Server status now starts as Disconnected rather than Connecting
+    * Improved error message when features are of an unexpected type
+ * Channel modes:
+    * CHANMODES feature is now stored as an array, not a single comma-separated string
+    * Added ChanModeType enum, and method in ServerState to get the type of a mode
+    * Added ModeChanged event, for user and channel mode changes and discovery
+ * Other new events:
+    * Added MotdFinished event
+    * Added UserAccountChanged event
  * Improved some documentation
- * Added ServerConnecting and ServerDisconnected events
- * Server status now starts as Disconnected rather than Connecting
- * CHANMODES feature is now stored as an array, not a single comma-separated string
- * Improved error message when features are of an unexpected type
 
 v0.4.0
 

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

 
 /** Raised when a Message Of the Day has completed. */
 class MotdFinished(time: LocalDateTime, val missing: Boolean = false): IrcEvent(time)
+
+/**
+ * Raised when a mode change occurs.
+ *
+ * If [discovered] is true then the event is in response to the server providing the full set of modes on the target,
+ * and the given modes are thus exhaustive. Otherwise, the modes are a sequence of changes to apply to the existing
+ * state.
+ */
+class ModeChanged(time: LocalDateTime, val target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false): IrcEvent(time)

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

 
     private val log by logger()
 
-    override val commands = arrayOf("005")
+    override val commands = arrayOf(RPL_ISUPPORT)
 
     override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(message.time, ServerFeatureMap().apply {
         // Ignore the first (nickname) and last ("are supported by this server") params

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

         CapabilityProcessor(),
         ISupportProcessor(),
         JoinProcessor(),
+        ModeProcessor(),
         MotdProcessor(),
         NamesProcessor(),
         PartProcessor(),

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

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ModeChanged
+import com.dmdirc.ktirc.model.IrcMessage
+
+internal class ModeProcessor : MessageProcessor {
+
+    override val commands = arrayOf(RPL_CHANNELMODEIS, RPL_UMODEIS, "MODE")
+
+    override fun process(message: IrcMessage): List<ModeChanged> {
+        val isDiscovery = message.command == RPL_CHANNELMODEIS || message.command == RPL_UMODEIS
+        val paramOffset = if (message.command == RPL_CHANNELMODEIS) 1 else 0
+        return listOf(ModeChanged(
+                message.time,
+                target = String(message.params[paramOffset]),
+                modes = String(message.params[paramOffset + 1]),
+                arguments = message.params.takeLast(message.params.size - paramOffset - 2).map { String(it) }.toTypedArray(),
+                discovered = isDiscovery))
+    }
+
+}

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

 
 internal class MotdProcessor : MessageProcessor {
 
-    override val commands = arrayOf("422", "376")
+    override val commands = arrayOf(ERR_NOMOTD, RPL_ENDOFMOTD)
 
     override fun process(message: IrcMessage) = sequence {
         when (message.command) {
-            "422" -> yield(MotdFinished(message.time, missing = true))
-            "376" -> yield(MotdFinished(message.time))
+            ERR_NOMOTD -> yield(MotdFinished(message.time, missing = true))
+            RPL_ENDOFMOTD -> yield(MotdFinished(message.time))
         }
     }.toList()
 

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

+package com.dmdirc.ktirc.messages
+
+internal const val RPL_WELCOME = "001"
+internal const val RPL_ISUPPORT = "005"
+
+internal const val RPL_UMODEIS = "221"
+
+internal const val RPL_CHANNELMODEIS = "324"
+internal const val RPL_ENDOFMOTD = "376"
+
+internal const val ERR_NOMOTD = "422"

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

 
 internal class WelcomeProcessor : MessageProcessor {
 
-    override val commands = arrayOf("001")
+    override val commands = arrayOf(RPL_WELCOME)
 
     override fun process(message: IrcMessage) = listOf(ServerWelcome(message.time, message.serverName(), String(message.params[0])))
 
     private fun IrcMessage.serverName() = prefix?.let { String(it) } ?: ""
+
 }

src/test/kotlin/com/dmdirc/ktirc/TestUtils.kt

+package com.dmdirc.ktirc
+
+internal fun params(vararg args: String) = args.map { it.toByteArray() }

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `AccountProcessor raises account changed event with account name`() {
         val events = AccountProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", listOf("acidBurn".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", params("acidBurn")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `AccountProcessor raises account changed event when account removed`() {
         val events = AccountProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", listOf("*".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", params("*")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `AccountProcessor does nothing if prefix missing`() {
         val events = AccountProcessor().process(
-                IrcMessage(emptyMap(), null, "ACCOUNT", listOf("*".toByteArray())))
+                IrcMessage(emptyMap(), null, "ACCOUNT", params("*")))
         assertEquals(0, events.size)
     }
 

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

 import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
 import com.dmdirc.ktirc.model.Capability
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.params
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
     @Test
     fun `CapabilityProcessor does nothing for unknown subcommand`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*".toByteArray(), "FOO".toByteArray())))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "FOO")))
 
         assertTrue(events.isEmpty())
     }
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event given no capabilities`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(0, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "chghost extended-join invalid")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with values for capabilities`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "chghost=test123 extended-join=abc=def invalid")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor overwrites earlier values with later ones for identical capabilities`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 chghost chghost=456").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "chghost=test123 chghost chghost=456")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(1, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities for multi-line responses`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "*", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "*", "chghost extended-join invalid")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesFinished event for final LS responses`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "LS", "chghost extended-join invalid")))
 
         assertEquals(2, events.size)
         assertTrue(events[1] is ServerCapabilitiesFinished)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesAcknowledged event`() {
-        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "ACK", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", params("*", "ACK", "chghost=test123 extended-join=abc=def invalid")))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesAcknowledged>()[0]
         assertEquals(2, receivedEvent.capabilities.size)

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

 import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.ServerFeatureMap
+import com.dmdirc.ktirc.params
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
     @Test
     fun `ISupportProcessor handles multiple numeric arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "MAXCHANNELS=123", "CHANNELLEN=456", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "MAXCHANNELS=123", "CHANNELLEN=456", "are supported blah blah")))
 
         assertEquals(123, events[0].serverFeatures[ServerFeature.MaximumChannels])
         assertEquals(456, events[0].serverFeatures[ServerFeature.MaximumChannelNameLength])
     @Test
     fun `ISupportProcessor handles string arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "NETWORK=abcd", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "NETWORK=abcd", "are supported blah blah")))
 
         assertEquals("abcd", events[0].serverFeatures[ServerFeature.Network])
     }
     @Test
     fun `ISupportProcessor handles string array arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "CHANMODES=abcd,efg,,hij", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "CHANMODES=abcd,efg,,hij", "are supported blah blah")))
 
         val modes = events[0].serverFeatures[ServerFeature.ChannelModes]!!
         assertEquals("abcd", modes[0])
     @Test
     fun `ISupportProcessor handles resetting arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "-CHANMODES", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "-CHANMODES", "are supported blah blah")))
 
         val oldFeatures = ServerFeatureMap()
         oldFeatures[ServerFeature.ChannelModes] = arrayOf("abc")
     @Test
     fun `ISupportProcessor handles case mapping arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "CASEMAPPING=rfc1459-strict", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "CASEMAPPING=rfc1459-strict", "are supported blah blah")))
 
         assertEquals(CaseMapping.RfcStrict, events[0].serverFeatures[ServerFeature.ServerCaseMapping])
     }
     @Test
     fun `ISupportProcessor handles mode prefix arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "PREFIX=(ovd)@+%", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "PREFIX=(ovd)@+%", "are supported blah blah")))
 
         assertEquals(ModePrefixMapping("ovd", "@+%"), events[0].serverFeatures[ServerFeature.ModePrefixes])
     }
     @Test
     fun `ISupportProcessor handles network arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "NETWORK=gibson", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "NETWORK=gibson", "are supported blah blah")))
 
         assertEquals("gibson", events[0].serverFeatures[ServerFeature.Network])
     }
     @Test
     fun `ISupportProcessor handles boolean features with no arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "WHOX", "are supported blah blah").map { it.toByteArray() }))
+                params("nickname", "WHOX", "are supported blah blah")))
 
         assertEquals(true, events[0].serverFeatures[ServerFeature.WhoxSupport])
     }

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `JoinProcessor raises join event`() {
         val events = JoinProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `JoinProcessor does nothing if prefix missing`() {
         val events = JoinProcessor().process(
-                IrcMessage(emptyMap(), null, "JOIN", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), null, "JOIN", params("#crashandburn")))
         assertEquals(0, events.size)
     }
 
     @Test
     fun `JoinProcessor adds real name and account from extended join`() {
         val events = JoinProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn", "acidBurn", "Libby").map { it.toByteArray() }))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "acidBurn", "Libby")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `JoinProcessor ignores account if the user is not authed`() {
         val events = JoinProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn", "*", "Libby").map { it.toByteArray() }))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "*", "Libby")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)

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

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.params
+import com.dmdirc.ktirc.util.currentTimeProvider
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class ModeProcessorTest {
+
+    @BeforeEach
+    fun setUp() {
+        currentTimeProvider = { TestConstants.time }
+    }
+
+    @Test
+    fun `raises event for user mode discovery with no params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "221", params("acidBurn", "+hax")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("acidBurn", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(0, events[0].arguments.size)
+        assertTrue(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for user mode discovery with params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "221", params("acidBurn", "+hax", "123", "467")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("acidBurn", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(2, events[0].arguments.size)
+        assertEquals("123", events[0].arguments[0])
+        assertEquals("467", events[0].arguments[1])
+        assertTrue(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for user mode change with no params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("acidBurn", "+hax")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("acidBurn", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(0, events[0].arguments.size)
+        assertFalse(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for user mode change with params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("acidBurn", "+hax", "123", "467")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("acidBurn", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(2, events[0].arguments.size)
+        assertEquals("123", events[0].arguments[0])
+        assertEquals("467", events[0].arguments[1])
+        assertFalse(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for channel mode discovery with no params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "324", params("acidBurn", "#thegibson", "+hax")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("#thegibson", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(0, events[0].arguments.size)
+        assertTrue(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for channel mode discovery with params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "324", params("acidBurn", "#thegibson", "+hax", "123", "467")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("#thegibson", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(2, events[0].arguments.size)
+        assertEquals("123", events[0].arguments[0])
+        assertEquals("467", events[0].arguments[1])
+        assertTrue(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for channel mode change with no params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("#thegibson", "+hax")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("#thegibson", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(0, events[0].arguments.size)
+        assertFalse(events[0].discovered)
+    }
+
+    @Test
+    fun `raises event for channel mode change with params`() {
+        val events = ModeProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("#thegibson", "+hax", "123", "467")))
+        assertEquals(1, events.size)
+
+        assertEquals(TestConstants.time, events[0].time)
+        assertEquals("#thegibson", events[0].target)
+        assertEquals("+hax", events[0].modes)
+        assertEquals(2, events[0].arguments.size)
+        assertEquals("123", events[0].arguments[0])
+        assertEquals("467", events[0].arguments[1])
+        assertFalse(events[0].discovered)
+    }
+
+}

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.events.MotdFinished
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `MotdProcessor raises motdFinished when not found numeric received`() {
         val events = MotdProcessor().process(
-                IrcMessage(emptyMap(), "the.gibson".toByteArray(), "422", listOf("MOTD missing".toByteArray())))
+                IrcMessage(emptyMap(), "the.gibson".toByteArray(), "422", params("MOTD missing")))
         assertEquals(1, events.size)
 
         val event = events[0] as MotdFinished
     @Test
     fun `MotdProcessor raises motdFinished when MOTD finishes normally`() {
         val events = MotdProcessor().process(
-                IrcMessage(emptyMap(), "the.gibson".toByteArray(), "376", listOf("acidBurn".toByteArray(), "End of /MOTD command.".toByteArray())))
+                IrcMessage(emptyMap(), "the.gibson".toByteArray(), "376", params("acidBurn", "End of /MOTD command.")))
         assertEquals(1, events.size)
 
         val event = events[0] as MotdFinished

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

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

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `PartProcessor raises part event without message`() {
         val events = PartProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", params("#crashandburn")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `PartProcessor raises part event with message`() {
         val events = PartProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray(), "Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", params("#crashandburn", "Hack the planet!")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `PartProcessor does nothing if prefix missing`() {
         val events = PartProcessor().process(
-                IrcMessage(emptyMap(), null, "PART", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), null, "PART", params("#crashandburn")))
         assertEquals(0, events.size)
     }
 

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

 import com.dmdirc.ktirc.events.MessageReceived
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `PrivsgProcessor raises message received event`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "hack the planet!")))
         assertEquals(1, events.size)
 
         val event = events[0] as MessageReceived
     @Test
     fun `PrivsgProcessor raises action received event with content`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001ACTION hacks the planet\u0001".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001ACTION hacks the planet\u0001")))
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
     @Test
     fun `PrivsgProcessor raises action received event without content`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001ACTION\u0001".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001ACTION\u0001")))
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
     @Test
     fun `PrivsgProcessor raises action received event with lowercase type`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001action hacks the planet\u0001".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001action hacks the planet\u0001")))
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
     @Test
     fun `PrivsgProcessor raises CTCP received event with content`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001PING 12345\u0001".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001PING 12345\u0001")))
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReceived
     @Test
     fun `PrivsgProcessor raises CTCP received event without content`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001PING\u0001".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001PING\u0001")))
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReceived
     @Test
     fun `PrivsgProcessor does nothing if prefix missing`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(emptyMap(), null, "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), null, "PRIVMSG", params("#crashandburn", "hack the planet!")))
         assertEquals(0, events.size)
     }
 }

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

 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
     @Test
     fun `QuitProcessor raises quit event with message`() {
         val events = QuitProcessor().process(
-                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", listOf("Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", params("Hack the planet!")))
         assertEquals(1, events.size)
 
         assertEquals(TestConstants.time, events[0].time)
     @Test
     fun `QuitProcessor does nothing if prefix missing`() {
         val events = QuitProcessor().process(
-                IrcMessage(emptyMap(), null, "QUIT", listOf("Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), null, "QUIT", params("Hack the planet!")))
         assertEquals(0, events.size)
     }
 

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

 
 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
         currentTimeProvider = { TestConstants.time }
     }
 
-    @Test
-    fun `WelcomeProcessor can handle 001s`() {
-        assertTrue(processor.commands.contains("001")) { "WelcomeProcessor should handle 001 messages" }
-    }
-
     @Test
     fun `WelcomeProcessor returns server welcome event`() {
-        val events = processor.process(IrcMessage(emptyMap(), "thegibson.com".toByteArray(), "001", listOf(
-                "acidBurn".toByteArray(),
-                "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
+        val events = processor.process(IrcMessage(emptyMap(), "thegibson.com".toByteArray(), "001", params(
+                "acidBurn", "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com")))
         assertEquals(1, events.size)
         assertEquals(TestConstants.time, events[0].time)
         assertEquals("acidBurn", events[0].localNick)