Add tests

test/com/dmdirc/parser/common/IgnoreListTest.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.common;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+
+public class IgnoreListTest {
+    
+    private final String[][] tests = {
+        {"a@b.c", "a@b\\.c"},
+        {"*chris*", ".*chris.*"},
+        {"c???s", "c...s"},
+        {"c*?*", "c.*..*"},
+        {"foo?", "foo."},
+        {".^$[]\\(){}|+", "\\.\\^\\$\\[\\]\\\\\\(\\)\\{\\}\\|\\+"},
+    }; 
+    
+    private final String[] illegals = {
+        "a+",
+        "a*",
+        "a.{4}",
+        "a|b",
+        "a?",
+        "foo\\",
+        "a\\?",
+        "a\\*",
+    };
+
+    @Test
+    public void testToRegex() {
+        for (String[] test : tests) {
+            final String convert1 = IgnoreList.simpleToRegex(test[0]);
+            assertEquals(test[1], convert1);
+        }
+    }
+    
+    @Test
+    public void testToSimple() {
+        for (String[] test : tests) {
+            final String convert2 = IgnoreList.regexToSimple(test[1]);
+            assertEquals(test[0], convert2);
+        }
+    }    
+    
+    @Test
+    public void testIllegals() {
+        for (String test : illegals) {
+            boolean except = false;
+            
+            try {
+                String converted = IgnoreList.regexToSimple(test);
+            } catch (UnsupportedOperationException ex) {
+                except = true;
+            }
+            
+            assertTrue(except);
+        }
+    }
+    
+    @Test
+    public void testConstructor() {
+        final List<String> items = Arrays.asList(new String[]{"abc", "def"});
+        final IgnoreList list = new IgnoreList(items);
+        
+        assertEquals(items, list.getRegexList());
+    }
+    
+    @Test
+    public void testAddSimple() {
+        final IgnoreList list = new IgnoreList();
+        
+        for (String[] test : tests) {
+            list.addSimple(test[0]);
+            assertTrue(list.getRegexList().contains(test[1]));
+        }
+    }
+    
+    @Test
+    public void testCanConvert() {
+        final IgnoreList list = new IgnoreList();
+        assertTrue(list.canConvert());
+        
+        list.addSimple("abc!def@ghi");
+        assertTrue(list.canConvert());
+        
+        list.add(illegals[0]);
+        assertFalse(list.canConvert());
+    }
+    
+    @Test
+    public void testGetSimpleList() throws UnsupportedOperationException {
+        final IgnoreList list = new IgnoreList();
+        final List<String> items = new ArrayList<String>();
+        
+        for (String[] test : tests) {
+            items.add(test[0]);
+            list.add(test[1]);
+        }
+        
+        assertEquals(items, list.getSimpleList());
+    }
+    
+}

test/com/dmdirc/parser/irc/ChannelClientInfoTest.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ChannelClientInfoTest {
+        
+    @Test
+    public void testImportantMode() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+
+        final IRCChannelClientInfo cci = parser.getClient("luser").getChannelClients().get(0);
+
+        assertEquals("v", cci.getImportantMode());
+        assertEquals("+", cci.getImportantModePrefix());
+        assertEquals("+luser", cci.toString());
+        assertEquals("+luser", cci.toFullString());
+        final long value = cci.getImportantModeValue();
+
+        parser.injectLine(":server MODE #DMDirc_testing +o luser");
+        assertEquals("o", cci.getImportantMode());
+        assertEquals("@", cci.getImportantModePrefix());
+        assertEquals("@luser", cci.toString());
+        assertEquals("@+luser", cci.toFullString());
+        assertTrue(cci.getImportantModeValue() > value);
+
+        parser.injectLine(":server MODE #DMDirc_testing -ov luser luser");
+        assertEquals("", cci.getImportantMode());
+        assertEquals("", cci.getImportantModePrefix());
+        assertEquals("luser", cci.toString());
+        assertEquals("luser", cci.toFullString());
+        assertEquals(0l, cci.getImportantModeValue());
+    }
+    
+    @Test
+    public void testMap() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        final Map<Object, Object> map1 = new HashMap<Object, Object>();
+        final Map<Object, Object> map2 = new HashMap<Object, Object>();
+        
+        final IRCChannelClientInfo cci = parser.getClient("nick").getChannelClients().get(0);
+        
+        cci.setMap(map1);
+        assertSame(map1, cci.getMap());
+        
+        cci.setMap(map2);
+        assertSame(map2, cci.getMap());
+    }
+    
+    @Test
+    public void testKick() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.sentLines.clear();
+        
+        parser.getClient("nick").getChannelClients().get(0).kick("");
+        assertEquals(1, parser.sentLines.size());
+        assertEquals("KICK #DMDirc_testing nick", parser.sentLines.get(0));
+        parser.sentLines.clear();
+        
+        parser.getClient("nick").getChannelClients().get(0).kick("booya");
+        assertEquals(1, parser.sentLines.size());
+        assertEquals("KICK #DMDirc_testing nick :booya", parser.sentLines.get(0));
+    }
+
+}

test/com/dmdirc/parser/irc/ChannelInfoTest.java

@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ChannelInfoTest {
+
+    final IRCChannelInfo ci = new IRCChannelInfo(null, "name");
+
+    @Test
+    public void testGetName() {
+        assertEquals("name", ci.getName());
+    }
+
+    @Test
+    public void testAddingNames() {
+        assertTrue(ci.isAddingNames());
+
+        ci.setAddingNames(false);
+
+        assertFalse(ci.isAddingNames());
+    }
+
+    @Test
+    public void testMap() {
+        final Map map = new HashMap();
+
+        ci.setMap(map);
+
+        assertEquals(map, ci.getMap());
+    }
+
+    @Test
+    public void testCreateTime() {
+        ci.setCreateTime(12345l);
+
+        assertEquals(12345l, ci.getCreateTime());
+    }
+
+    @Test
+    public void testTopicTime() {
+        ci.setTopicTime(12345l);
+
+        assertEquals(12345l, ci.getTopicTime());
+    }
+
+    @Test
+    public void testTopic() {
+        ci.setInternalTopic("abcdef");
+
+        assertEquals("abcdef", ci.getTopic());
+    }
+
+    @Test
+    public void testSendMessage() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendMessage("hello");
+
+        assertEquals("PRIVMSG #DMDirc_testing :hello", parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendNotice() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendNotice("hello");
+
+        assertEquals("NOTICE #DMDirc_testing :hello", parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendCTCP() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendCTCP("type", "hello");
+
+        assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "TYPE hello" + ((char) 1),
+                parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendCTCPEmpty() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendCTCP("type", "");
+
+        assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "TYPE" + ((char) 1),
+                parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendAction() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendAction("moo");
+
+        assertEquals("PRIVMSG #DMDirc_testing :" + ((char) 1) + "ACTION moo" + ((char) 1),
+                parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendCTCPReply() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendCTCPReply("type", "moo");
+
+        assertEquals("NOTICE #DMDirc_testing :" + ((char) 1) + "TYPE moo" + ((char) 1),
+                parser.sentLines.get(0));
+    }
+
+    @Test
+    public void testSendCTCPReplyEmpty() {
+        final TestParser parser = new TestParser();
+        getChannel(parser).sendCTCPReply("type", "");
+
+        assertEquals("NOTICE #DMDirc_testing :" + ((char) 1) + "TYPE" + ((char) 1),
+                parser.sentLines.get(0));
+    }
+    
+    @Test
+    public void testSendEmptyMessages() {
+        final TestParser parser = new TestParser();
+        final IRCChannelInfo info = getChannel(parser);
+        
+        info.sendAction("");
+        info.sendCTCP("", "");
+        info.sendCTCPReply("", "");
+        info.sendMessage("");
+        info.sendNotice("");
+
+        assertEquals(0, parser.sentLines.size());
+    }
+    
+    @Test
+    public void testGetSetParamMode() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+        parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
+        parser.sentLines.clear();
+        
+        assertEquals("lalala", info.getMode('k'));
+        assertEquals("", info.getMode('z'));
+        
+        parser.injectLine(":server MODE #DMDirc_testing -k *");
+        
+        assertEquals("", info.getMode('k'));
+    }
+    
+    @Test
+    public void testModeSendFull() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+
+        parser.sentLines.clear();
+        info.alterMode(true, 'i', null);
+        info.alterMode(true, 'm', null);
+        info.alterMode(true, 'n', null);
+        info.alterMode(true, 'p', null);
+        info.alterMode(true, 't', null);
+        info.alterMode(true, 'r', null);
+        
+        assertEquals("Parser must send modes as soon as the max number is reached",
+                1, parser.sentLines.size());
+        final String modes = getModes(parser.sentLines.get(0));
+        
+        assertTrue(modes.indexOf('i') > -1);
+        assertTrue(modes.indexOf('m') > -1);
+        assertTrue(modes.indexOf('n') > -1);
+        assertTrue(modes.indexOf('p') > -1);
+        assertTrue(modes.indexOf('t') > -1);
+        assertTrue(modes.indexOf('r') > -1);
+    }
+    
+    @Test
+    public void testModeSendExtra() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+
+        parser.sentLines.clear();
+        info.alterMode(true, 'i', null);
+        info.alterMode(true, 'm', null);
+        info.alterMode(true, 'n', null);
+        info.alterMode(true, 'p', null);
+        info.alterMode(true, 't', null);
+        info.alterMode(true, 'r', null);
+        info.alterMode(true, 'N', null);
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes",
+                2, parser.sentLines.size());
+        
+        final String modes = getModes(parser.sentLines.get(0))
+                + getModes(parser.sentLines.get(1));
+        
+        assertTrue(modes.indexOf('i') > -1);
+        assertTrue(modes.indexOf('m') > -1);
+        assertTrue(modes.indexOf('n') > -1);
+        assertTrue(modes.indexOf('p') > -1);
+        assertTrue(modes.indexOf('t') > -1);
+        assertTrue(modes.indexOf('r') > -1);
+        assertTrue(modes.indexOf('N') > -1);
+    }
+    
+    @Test
+    public void testModeSendOptimisation1() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+
+        parser.sentLines.clear();
+        info.alterMode(true, 'i', null);
+        info.alterMode(true, 'm', null);
+        info.alterMode(true, 'n', null);
+        info.alterMode(true, 'n', null);
+        info.alterMode(false, 'i', null);
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes in one go",
+                1, parser.sentLines.size());
+        
+        final String modes = getModes(parser.sentLines.get(0));
+        
+        assertEquals("Setting a negative mode should cancel a positive one",
+                -1, modes.indexOf('i'));
+        
+        assertTrue(modes.indexOf('m') > -1);
+    }
+    
+    @Test
+    public void testModeSendOptimisation2() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+
+        parser.sentLines.clear();
+        info.alterMode(true, 'm', null);
+        info.alterMode(true, 'n', null);
+        info.alterMode(true, 'n', null);
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes in one go",
+                1, parser.sentLines.size());
+        
+        final String modes = getModes(parser.sentLines.get(0));
+        
+        assertEquals("Setting a mode twice should have no effect",
+                modes.indexOf('n'), modes.lastIndexOf('n'));
+        
+        assertTrue(modes.indexOf('m') > -1);
+    }
+    
+    @Test
+    public void testModeUnsetKey() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+        parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
+        parser.sentLines.clear();
+        
+        info.alterMode(true, 'k', "foobar");
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes in one go",
+                1, parser.sentLines.size());
+        assertEquals("Setting +k must set -k first",
+                "-k+k lalala foobar", getModes(parser.sentLines.get(0)));
+    }
+    
+    @Test
+    public void testIssue1410() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":foo!bar@baz JOIN #DMDirc_testing");
+        parser.injectLine(":flub!floo@fleeee JOIN #DMDirc_testing");
+
+        assertNotSame(parser.getChannel("#DMDirc_testing").getChannelClients(),
+                parser.getChannel("#DMDirc_testing").getChannelClients());
+        assertEquals(parser.getChannel("#DMDirc_testing").getChannelClients(),
+                parser.getChannel("#DMDirc_testing").getChannelClients());
+    }
+    
+    @Test @Ignore
+    public void testModeUnsetKeyMultiple() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+        parser.injectLine(":server 324 nick #DMDirc_testing +k lalala");
+        parser.sentLines.clear();
+        
+        info.alterMode(true, 'k', "foobar");
+        info.alterMode(true, 'k', "blahblah");
+        info.alterMode(true, 'k', "unittest");
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes in one go",
+                1, parser.sentLines.size());
+        assertEquals("Setting a mode multiple times should have no effect",
+                "-k+k lalala unittest", getModes(parser.sentLines.get(0)));
+    }
+    
+    @Test @Ignore
+    public void testModeUnsetLimitMultiple() {
+        final TestParser parser = new TestParser();
+        final ChannelInfo info = getChannel(parser);
+        parser.injectLine(":server 324 nick #DMDirc_testing +l 73");
+        parser.sentLines.clear();
+        
+        info.alterMode(true, 'l', "74");
+        info.alterMode(true, 'l', "75");
+        info.alterMode(true, 'l', "76");
+        info.flushModes();
+        
+        assertEquals("sendModes must send modes in one go",
+                1, parser.sentLines.size());
+        assertEquals("Setting a mode multiple times should have no effect",
+                "+l 76", getModes(parser.sentLines.get(0)));
+    }
+    
+    private String getModes(final String line) {
+        final String res = line.substring("MODE #DMDirc_testing ".length());
+        
+        if (res.charAt(0) == '+') {
+            return res.substring(1);
+        }
+        
+        return res;
+    }
+
+    private IRCChannelInfo getChannel(final TestParser parser) {
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+
+        parser.sentLines.clear();
+        return parser.getChannels().iterator().next();
+    }
+
+}

test/com/dmdirc/parser/irc/ClientInfoTest.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ClientInfoTest {
+    
+    @Test
+    public void testMap() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        final Map<Object, Object> map = new HashMap<Object, Object>();
+        
+        ci.setMap(map);
+        assertEquals(map, ci.getMap());
+    }
+    
+    @Test
+    public void testFake() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        assertFalse(ci.isFake());
+        ci.setFake(true);
+        assertTrue(ci.isFake());
+        ci.setFake(false);
+        assertFalse(ci.isFake());
+    }
+    
+    @Test
+    public void testParseHost() {
+        final String string1 = ":nick!ident@host";
+        final String string2 = "nick";
+        final String string3 = ":nick@host";
+        
+        assertEquals("nick", IRCClientInfo.parseHost(string1));
+        assertEquals("nick", IRCClientInfo.parseHost(string2));
+        assertEquals("nick", IRCClientInfo.parseHost(string3));
+    }
+    
+    @Test
+    public void testParseHostFull() {
+        final String string1 = ":nick!ident@host";
+        final String string2 = "nick";
+        final String string3 = ":nick@host";
+        
+        assertEquals("nick", IRCClientInfo.parseHostFull(string1)[0]);
+        assertEquals("ident", IRCClientInfo.parseHostFull(string1)[1]);
+        assertEquals("host", IRCClientInfo.parseHostFull(string1)[2]);
+        
+        assertEquals("nick", IRCClientInfo.parseHostFull(string2)[0]);
+        assertEquals("nick", IRCClientInfo.parseHostFull(string3)[0]);
+        assertEquals("host", IRCClientInfo.parseHostFull(string3)[2]);
+    }
+    
+    @Test
+    public void testSetUserBits() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        ci.setUserBits("nick2!ident2@host2", false);
+        
+        assertEquals("nick", ci.getNickname());
+        assertEquals("ident2", ci.getUsername());
+        assertEquals("host2", ci.getHostname());
+        
+        ci.setUserBits(":nick3@host3", true);
+        
+        assertEquals("nick3", ci.getNickname());
+        assertEquals("ident2", ci.getUsername());
+        assertEquals("host3", ci.getHostname());
+    }
+    
+    @Test
+    public void testToString() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        assertEquals("nick!ident@host", ci.toString());
+    }
+    
+    @Test
+    public void testAwayState() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        assertFalse(ci.getAwayState());
+        ci.setAwayState(true);
+        assertTrue(ci.getAwayState());
+    }
+    
+    @Test
+    public void testAwayReason() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        ci.setAwayState(true);
+        ci.setAwayReason("away reason");
+        
+        assertEquals("away reason", ci.getAwayReason());
+        ci.setAwayState(false);
+        assertEquals("", ci.getAwayReason());
+    }
+    
+    @Test
+    public void testRealName() {
+        final IRCClientInfo ci = new IRCClientInfo(new IRCParser(), "nick!ident@host");
+        ci.setRealName("abc def");
+        assertEquals("abc def", ci.getRealname());
+        ci.setRealName("abc 123 def");
+        assertEquals("abc 123 def", ci.getRealname());
+    }
+    
+}

test/com/dmdirc/parser/irc/IRCParserTest.java

@@ -0,0 +1,540 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.parser.common.MyInfo;
+import com.dmdirc.parser.common.ChannelListModeItem;
+import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.harness.parser.TestIPrivateCTCP;
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIConnectError;
+import com.dmdirc.harness.parser.TestINoticeAuth;
+import com.dmdirc.harness.parser.TestINumeric;
+import com.dmdirc.harness.parser.TestIServerError;
+import com.dmdirc.harness.parser.TestIPost005;
+import com.dmdirc.harness.parser.TestIPrivateMessage;
+import com.dmdirc.harness.parser.TestIPrivateAction;
+import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
+import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
+import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
+
+import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.NumericListener;
+import com.dmdirc.parser.interfaces.callbacks.Post005Listener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpListener;
+import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
+import com.dmdirc.parser.interfaces.callbacks.ServerErrorListener;
+import java.util.Arrays;
+import java.util.Collection;
+
+import javax.net.ssl.TrustManager;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+public class IRCParserTest {
+
+    private static interface TestCallback extends CallbackInterface { }
+
+    @Test
+    public void testIssue42() {
+        // Invalid callback names are silently ignored instead of raising exceptions
+        
+        boolean res = false;
+
+        try {
+            final IRCParser myParser = new IRCParser();
+            myParser.getCallbackManager().addCallback(TestCallback.class, mock(TestCallback.class));
+        } catch (CallbackNotFoundException ex) {
+            res = true;
+        }
+
+        assertTrue("addCallback() should throw exception for non-existant callbacks", res);
+    }
+
+    @Test
+    public void testIssue1674() {
+        // parser nick change error with dual 001
+        final ErrorInfoListener error = mock(ErrorInfoListener.class);
+
+        final TestParser myParser = new TestParser();
+        myParser.getCallbackManager().addCallback(ErrorInfoListener.class, error);
+        myParser.injectConnectionStrings();
+        myParser.nick = "nick2";
+        myParser.injectConnectionStrings();
+        myParser.injectLine(":nick2!ident@host NICK :nick");
+
+        verify(error, never()).onErrorInfo((IRCParser) anyObject(), (ParserError) anyObject());
+    }
+    
+    @Test
+    public void testProxyPortWithBindIP() {
+        final TestIConnectError tice = new TestIConnectError();
+        final ServerInfo si = new ServerInfo();
+        si.setProxyPort(155555);
+        si.setUseSocks(true);
+        
+        final IRCParser myParser = new IRCParser(si);
+        myParser.getCallbackManager().addCallback(ConnectErrorListener.class, tice);
+        myParser.setBindIP("0.0.0.0");
+        myParser.run();
+        
+        assertTrue("Using an invalid socks proxy port should raise a connect error event",
+                tice.error);
+    }
+
+    @Test
+    public void testTokeniser() {
+        final String line1 = "a b c d e";
+        final String line2 = "a b c :d e";
+        final String line3 = ":a b:c :d e";
+        final String line4 = null;
+
+        final String[] res1 = IRCParser.tokeniseLine(line1);
+        final String[] res2 = IRCParser.tokeniseLine(line2);
+        final String[] res3 = IRCParser.tokeniseLine(line3);
+        final String[] res4 = IRCParser.tokeniseLine(line4);
+
+        assertTrue(Arrays.equals(res1, new String[]{"a", "b", "c", "d", "e"}));
+        assertTrue(Arrays.equals(res2, new String[]{"a", "b", "c", "d e"}));
+        assertTrue(Arrays.equals(res3, new String[]{":a", "b:c", "d e"}));
+        assertTrue(Arrays.equals(res4, new String[]{""}));
+    }
+
+    @Test
+    public void testSendConnectionStrings1() {
+        final ServerInfo serverInfo = new ServerInfo("irc.testing.dmdirc", 6667, "");
+        final MyInfo myInfo = new MyInfo();
+        myInfo.setNickname("Nickname");
+        myInfo.setRealname("Real name");
+        myInfo.setUsername("Username");
+
+        final TestParser parser = new TestParser(myInfo, serverInfo);
+        parser.sendConnectionStrings();
+
+        assertEquals(2, parser.sentLines.size());
+
+        assertTrue("Should send nickname line",
+                Arrays.equals(parser.getLine(0), new String[]{"NICK", "Nickname"}));
+
+        final String[] userParts = parser.getLine(1);
+        assertEquals("First token should be USER", "USER", userParts[0]);
+        assertEquals("USER should contain username", myInfo.getUsername().toLowerCase(),
+                userParts[1].toLowerCase());
+        assertEquals("USER should contain server name", serverInfo.getHost(), userParts[3]);
+        assertEquals("USER should contain real name", "Real name", userParts[4]);
+    }
+
+    @Test
+    public void testSendConnectionStrings2() {
+        final ServerInfo serverInfo = new ServerInfo("irc.testing.dmdirc", 6667, "password");
+        final MyInfo myInfo = new MyInfo();
+        myInfo.setNickname("Nickname");
+        myInfo.setRealname("Real name");
+        myInfo.setUsername("Username");
+
+        final TestParser parser = new TestParser(myInfo, serverInfo);
+        parser.sendConnectionStrings();
+
+        assertEquals(3, parser.sentLines.size());
+
+        assertTrue("Should send password line",
+                Arrays.equals(parser.getLine(0), new String[]{"PASS", "password"}));
+    }
+
+    @Test
+    public void testPingPong() {
+        final TestParser parser = new TestParser();
+
+        parser.injectLine("PING :flubadee7291");
+
+        assertTrue("Should reply to PINGs with PONGs",
+                Arrays.equals(parser.getLine(0), new String[]{"PONG", "flubadee7291"}));
+    }
+
+    @Test
+    public void testError() throws CallbackNotFoundException {
+        final TestIServerError test = new TestIServerError();
+
+        final TestParser parser = new TestParser();
+        parser.getCallbackManager().addCallback(ServerErrorListener.class, test);
+        parser.injectLine("ERROR :You smell of cheese");
+
+        assertNotNull(test.message);
+        assertEquals("ERROR message should be passed to callback",
+                "You smell of cheese", test.message);
+    }
+
+    @Test
+    public void testAuthNotices() throws CallbackNotFoundException {
+        final TestINoticeAuth test = new TestINoticeAuth();
+        final TestParser parser = new TestParser();
+        parser.getCallbackManager().addCallback(AuthNoticeListener.class, test);
+        parser.sendConnectionStrings();
+        parser.injectLine("NOTICE AUTH :Random auth notice?");
+
+        assertNotNull(test.message);
+        assertEquals("Random auth notice?", test.message);
+
+        test.message = null;
+
+        parser.injectLine(":us.ircnet.org 020 * :Stupid notice");
+
+        assertNotNull(test.message);
+        assertEquals("Stupid notice", test.message);
+    }
+
+    @Test
+    public void testPre001NickChange() throws CallbackNotFoundException {
+        final TestINoticeAuth test = new TestINoticeAuth();
+        final TestParser parser = new TestParser();
+        parser.getCallbackManager().addCallback(AuthNoticeListener.class, test);
+        parser.sendConnectionStrings();
+        parser.injectLine(":chris!@ NICK :user2");
+
+        assertNull(test.message);
+    }
+
+    @Test
+    public void testNumeric() throws CallbackNotFoundException {
+        final TestINumeric test = new TestINumeric();
+        final TestParser parser = new TestParser();
+        parser.getCallbackManager().addCallback(NumericListener.class, test);
+
+        parser.injectLine(":server 001 nick :Hi there, nick");
+
+        assertEquals(1, test.numeric);
+        assertTrue(Arrays.equals(new String[]{":server", "001", "nick", "Hi there, nick"},
+                test.data));
+    }
+
+    @Test
+    public void testPost005() throws CallbackNotFoundException {
+        final TestIPost005 test = new TestIPost005();
+        final TestParser parser = new TestParser();
+        parser.getCallbackManager().addCallback(Post005Listener.class, test);
+
+        final String[] strings = {
+            "NOTICE AUTH :Blah, blah",
+            ":server 020 * :Blah! Blah!",
+            ":server 001 nick :Welcome to the Testing IRC Network, nick",
+            ":server 002 nick :Your host is server.net, running version foo",
+            "NOTICE AUTH :I'm a retarded server",
+            ":server 003 nick :This server was created Sun Jan 6 2008 at 17:34:54 CET",
+            ":server 004 nick server.net foo dioswkgxRXInP biklmnopstvrDcCNuMT bklov",
+            ":server 005 nick WHOX WALLCHOPS WALLVOICES USERIP :are supported by this server",
+            ":server 005 nick MAXNICKLEN=15 TOPICLEN=250 AWAYLEN=160 :are supported " +
+                    "by this server",
+            ":server 375 nick :zomg, motd!",
+        };
+
+        for (String string : strings) {
+            assertFalse("OnPost005 fired too early", test.done);
+            parser.injectLine(string);
+        }
+
+        assertTrue("OnPost005 not fired", test.done);
+    }
+
+    @Test
+    public void test005Parsing() {
+        final TestParser parser = new TestParser();
+
+        final String[] strings = {
+            ":server 001 nick :Welcome to the Testing IRC Network, nick",
+            ":server 002 nick :Your host is server.net, running version foo",
+            ":server 003 nick :This server was created Sun Jan 6 2008 at 17:34:54 CET",
+            ":server 004 nick server.net foo dioswkgxRXInP biklmnopstvrDcCNuMT bklov",
+            ":server 005 nick WHOX WALLCHOPS WALLVOICES NETWORK=moo :are supported by" +
+                    " this server",
+            ":server 005 nick MAXNICKLEN=15 MAXLIST=b:10,e:22,I:45 :are supported by" +
+                    " this server",
+            ":server 375 nick :zomg, motd!",
+        };
+
+        for (String string : strings) {
+            parser.injectLine(string);
+        }
+
+        assertEquals(10, parser.getMaxListModes('b'));
+        assertEquals(22, parser.getMaxListModes('e'));
+        assertEquals(45, parser.getMaxListModes('I'));
+        assertEquals("getMaxListModes should return 0 for unknowns;", 0,
+                parser.getMaxListModes('z'));
+        assertEquals("moo", parser.getNetworkName());
+        assertEquals("server", parser.getServerName());
+    }
+
+    @Test
+    public void testBindIP() {
+        final TestParser parser = new TestParser();
+
+        parser.setBindIP("abc.def.ghi.123");
+        assertEquals("abc.def.ghi.123", parser.getBindIP());
+    }
+
+    @Test
+    public void testCreateFake() {
+        final TestParser parser = new TestParser();
+
+        parser.setCreateFake(false);
+        assertFalse(parser.getCreateFake());
+        parser.setCreateFake(true);
+        assertTrue(parser.getCreateFake());
+    }
+
+    @Test
+    public void testAutoListMode() {
+        final TestParser parser = new TestParser();
+
+        parser.setAutoListMode(false);
+        assertFalse(parser.getAutoListMode());
+        parser.setAutoListMode(true);
+        assertTrue(parser.getAutoListMode());
+    }
+
+    @Test
+    public void testRemoveAfterCallback() {
+        final TestParser parser = new TestParser();
+
+        parser.setRemoveAfterCallback(false);
+        assertFalse(parser.getRemoveAfterCallback());
+        parser.setRemoveAfterCallback(true);
+        assertTrue(parser.getRemoveAfterCallback());
+    }
+
+    @Test
+    public void testAddLastLine() {
+        final TestParser parser = new TestParser();
+
+        parser.setAddLastLine(false);
+        assertFalse(parser.getAddLastLine());
+        parser.setAddLastLine(true);
+        assertTrue(parser.getAddLastLine());
+    }
+
+    @Test
+    public void testDisconnectOnFatal() {
+        final TestParser parser = new TestParser();
+
+        parser.setDisconnectOnFatal(false);
+        assertFalse(parser.getDisconnectOnFatal());
+        parser.setDisconnectOnFatal(true);
+        assertTrue(parser.getDisconnectOnFatal());
+    }
+
+    @Test
+    public void testTrustManager() {
+        final TestParser parser = new TestParser();
+
+        assertTrue(Arrays.equals(parser.getDefaultTrustManager(), parser.getTrustManager()));
+
+        parser.setTrustManagers(new TrustManager[0]);
+
+        assertTrue(Arrays.equals(new TrustManager[0], parser.getTrustManager()));
+    }
+
+    @Test
+    public void testPrivateMessages() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIPrivateMessage ipmtest = new TestIPrivateMessage();
+        final TestIPrivateAction ipatest = new TestIPrivateAction();
+        final TestIPrivateCTCP ipctest = new TestIPrivateCTCP();
+
+        parser.injectConnectionStrings();
+
+        parser.getCallbackManager().addCallback(PrivateMessageListener.class, ipmtest);
+        parser.getCallbackManager().addCallback(PrivateActionListener.class, ipatest);
+        parser.getCallbackManager().addCallback(PrivateCtcpListener.class, ipctest);
+
+        parser.injectLine(":a!b@c PRIVMSG nick :Hello!");
+        assertNotNull(ipmtest.host);
+        assertNull(ipatest.host);
+        assertNull(ipctest.host);
+        assertEquals("a!b@c", ipmtest.host);
+        assertEquals("Hello!", ipmtest.message);
+        ipmtest.host = null;
+        ipmtest.message = null;
+
+        parser.injectLine(":a!b@c PRIVMSG nick :" + ((char) 1) + "ACTION meep" + ((char) 1));
+        assertNull(ipmtest.host);
+        assertNotNull(ipatest.host);
+        assertNull(ipctest.host);
+        assertEquals("a!b@c", ipatest.host);
+        assertEquals("meep", ipatest.message);
+        ipatest.host = null;
+        ipatest.message = null;
+
+        parser.injectLine(":a!b@c PRIVMSG nick :" + ((char) 1) + "FOO meep" + ((char) 1));
+        assertNull(ipmtest.host);
+        assertNull(ipatest.host);
+        assertNotNull(ipctest.host);
+        assertEquals("a!b@c", ipctest.host);
+        assertEquals("FOO", ipctest.type);
+        assertEquals("meep", ipctest.message);
+    }
+
+    private void testListModes(String numeric1, String numeric2, char mode) {
+        final TestParser parser = new TestParser();
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #D");
+        parser.injectLine(":server " + numeric1 + " nick #D ban1!ident@.host bansetter1 1001");
+        parser.injectLine(":server " + numeric1 + " nick #D ban2!*@.host bansetter2 1002");
+        parser.injectLine(":server " + numeric1 + " nick #D ban3!ident@* bansetter3 1003");
+        parser.injectLine(":server " + numeric2 + " nick #D :End of Channel Something List");
+
+        final Collection<ChannelListModeItem> items
+                = parser.getChannel("#D").getListMode(mode);
+
+        assertEquals(3, items.size());
+        boolean gotOne = false, gotTwo = false, gotThree = false;
+
+        for (ChannelListModeItem item : items) {
+            if (item.getItem().equals("ban1!ident@.host")) {
+                assertEquals("bansetter1", item.getOwner());
+                assertEquals(1001l, item.getTime());
+                assertFalse(gotOne);
+                gotOne = true;
+            } else if (item.getItem().equals("ban2!*@.host")) {
+                assertEquals("bansetter2", item.getOwner());
+                assertEquals(1002l, item.getTime());
+                assertFalse(gotTwo);
+                gotTwo = true;
+            } else if (item.toString().equals("ban3!ident@*")) {
+                assertEquals("bansetter3", item.getOwner());
+                assertEquals(1003l, item.getTime());
+                assertFalse(gotThree);
+                gotThree = true;
+            }
+        }
+
+        assertTrue(gotOne);
+        assertTrue(gotTwo);
+        assertTrue(gotThree);
+    }
+
+    @Test
+    public void testNormalBans() {
+        testListModes("367", "368", 'b');
+    }
+
+    @Test
+    public void testInvexList() {
+        testListModes("346", "347", 'I');
+    }
+
+    @Test
+    public void testExemptList() {
+        testListModes("348", "349", 'e');
+    }
+
+    @Test
+    public void testReopList() {
+        testListModes("344", "345", 'R');
+    }
+
+    @Test
+    public void testGetParam() {
+        assertEquals("abc def", TestParser.getParam("foo :abc def"));
+        assertEquals("bar :abc def", TestParser.getParam("foo :bar :abc def"));
+        assertEquals("abc def", TestParser.getParam("abc def"));
+    }
+    
+    @Test
+    public void testKick() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final ChannelKickListener ick = mock(ChannelKickListener.class);
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #D");
+        parser.getCallbackManager().addCallback(ChannelKickListener.class, ick, "#D");
+        parser.injectLine(":bar!me@moo KICK #D nick :Bye!");
+
+        verify(ick).onChannelKick(same(parser), (IRCChannelInfo) anyObject(),
+                (IRCChannelClientInfo) anyObject(), (IRCChannelClientInfo) anyObject(),
+                anyString(), anyString());
+    }
+
+    @Test
+    public void testIRCds() {
+        doIRCdTest("u2.10.12.10+snircd(1.3.4)", "snircd");
+        doIRCdTest("u2.10.12.12", "ircu");
+        doIRCdTest("hyperion-1.0.2b", "hyperion");
+        doIRCdTest("hybrid-7.2.3", "hybrid");
+        doIRCdTest("Unreal3.2.6", "unreal");
+        doIRCdTest("bahamut-1.8(04)", "bahamut");
+    }
+    
+    @Test
+    public void testIllegalPort1() {
+        final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 0, ""));
+        final TestIConnectError tiei = new TestIConnectError();
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
+        tp.runSuper();
+        assertTrue(tiei.error);
+    }
+    
+    @Test
+    public void testIllegalPort2() {
+        final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 1, ""));
+        final TestIConnectError tiei = new TestIConnectError();
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
+        tp.runSuper();
+        assertTrue(tiei.error);
+    }    
+    
+    @Test
+    public void testIllegalPort3() {
+        final TestParser tp = new TestParser(new MyInfo(), new ServerInfo("127.0.0.1", 65570, ""));
+        final TestIConnectError tiei = new TestIConnectError();
+        tp.getCallbackManager().addCallback(ConnectErrorListener.class, tiei);
+        tp.runSuper();
+        assertTrue(tiei.error);
+    }
+
+    private void doIRCdTest(final String ircd, final String expected) {
+        final TestParser parser = new TestParser();
+
+        String[] strings = {
+            ":server 001 nick :Welcome to the Testing IRC Network, nick",
+            ":server 002 nick :Your host is server.net, running version %s",
+            ":server 003 nick :This server was created Sun Jan 6 2008 at 17:34:54 CET",
+            ":server 004 nick server.net %s dioswkgxRXInP biklmnopstvrDcCNuMT bklov"
+        };
+
+        for (String line : strings) {
+            parser.injectLine(String.format(line, ircd));
+        }
+
+        assertEquals(ircd, parser.getServerSoftware());
+        assertEquals(expected.toLowerCase(), parser.getServerSoftwareType().toLowerCase());
+    }
+
+}

test/com/dmdirc/parser/irc/IRCStringConverterTest.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.dmdirc.parser.irc;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class IRCStringConverterTest {
+
+    @Test
+    public void testCaseConversion() {
+        final IRCParser asciiParser = new IRCParser();
+        asciiParser.updateCharArrays((byte) 0);
+
+        final IRCParser rfcParser = new IRCParser();
+        rfcParser.updateCharArrays((byte) 4);
+
+        final IRCParser strictParser = new IRCParser();
+        strictParser.updateCharArrays((byte) 3);
+
+        final String[][] testcases = {
+            {"12345", "12345", "12345", "12345"},
+            {"HELLO", "hello", "hello", "hello"},
+            {"^[[MOO]]^", "^[[moo]]^", "~{{moo}}~", "^{{moo}}^"},
+            {"«—»", "«—»", "«—»", "«—»"},
+        };
+
+        for (String[] testcase : testcases) {
+            final String asciiL = asciiParser.getStringConverter().toLowerCase(testcase[0]);
+            final String rfcL = rfcParser.getStringConverter().toLowerCase(testcase[0]);
+            final String strictL = strictParser.getStringConverter().toLowerCase(testcase[0]);
+
+            final String asciiU = asciiParser.getStringConverter().toUpperCase(testcase[1]);
+            final String rfcU = rfcParser.getStringConverter().toUpperCase(testcase[2]);
+            final String strictU = strictParser.getStringConverter().toUpperCase(testcase[3]);
+
+            assertEquals(testcase[1], asciiL);
+            assertEquals(testcase[2], rfcL);
+            assertEquals(testcase[3], strictL);
+
+            assertTrue(asciiParser.getStringConverter().equalsIgnoreCase(testcase[0], testcase[1]));
+            assertTrue(rfcParser.getStringConverter().equalsIgnoreCase(testcase[0], testcase[2]));
+            assertTrue(strictParser.getStringConverter().equalsIgnoreCase(testcase[0], testcase[3]));
+
+            assertEquals(testcase[0], asciiU);
+            assertEquals(testcase[0], rfcU);
+            assertEquals(testcase[0], strictU);
+        }
+    }
+    
+    @Test
+    public void testLimit() {
+        final IRCStringConverter ircsc = new IRCStringConverter((byte) 100);
+        
+        assertEquals(4, ircsc.getLimit());
+    }
+    
+    @Test
+    public void testEqualsNull() {
+        final IRCStringConverter ircsc = new IRCStringConverter((byte) 100);
+        
+        assertTrue(ircsc.equalsIgnoreCase(null, null));
+        assertFalse(ircsc.equalsIgnoreCase("null", null));
+        assertFalse(ircsc.equalsIgnoreCase(null, "null"));
+    }    
+
+}

test/com/dmdirc/parser/irc/ParserErrorTest.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.parser.common.ParserError;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ParserErrorTest {
+
+    private final ParserError fatal = new ParserError(ParserError.ERROR_FATAL, "moo", "");
+    private final ParserError error = new ParserError(ParserError.ERROR_ERROR, "moo", "last line");
+    private final ParserError except = new ParserError(ParserError.ERROR_EXCEPTION, "moo", null);
+    private final ParserError warning = new ParserError(ParserError.ERROR_WARNING, "moo", "");
+    private final ParserError uwarning = new ParserError(ParserError.ERROR_WARNING
+            + ParserError.ERROR_USER, "moo", "");
+
+    @Test
+    public void testIsFatal() {
+        assertTrue(fatal.isFatal());
+        assertFalse(error.isFatal());
+        assertFalse(except.isFatal());
+        assertFalse(warning.isFatal());
+    }
+
+    @Test
+    public void testIsError() {
+        assertTrue(error.isError());
+        assertFalse(fatal.isError());
+        assertFalse(except.isError());
+        assertFalse(warning.isError());
+    }
+
+    @Test
+    public void testIsWarning() {
+        assertFalse(error.isWarning());
+        assertFalse(fatal.isWarning());
+        assertFalse(except.isWarning());
+        assertTrue(warning.isWarning());
+    }
+
+    @Test
+    public void testIsException() {
+        assertFalse(error.isException());
+        assertFalse(fatal.isException());
+        assertTrue(except.isException());
+        assertFalse(warning.isException());        
+    }
+
+    @Test
+    public void testHasLastLine() {
+        assertTrue(error.hasLastLine());
+        assertFalse(fatal.hasLastLine());
+        assertFalse(except.hasLastLine());
+        assertFalse(warning.hasLastLine());
+    }
+    
+    @Test
+    public void testGetLevel() {
+        assertEquals(ParserError.ERROR_ERROR, error.getLevel());
+        assertEquals(ParserError.ERROR_EXCEPTION, except.getLevel());
+        assertEquals(ParserError.ERROR_FATAL, fatal.getLevel());
+        assertEquals(ParserError.ERROR_WARNING, warning.getLevel());
+    }    
+    
+    @Test
+    public void testIsUser() {
+        assertTrue(uwarning.isUserError());
+        assertFalse(error.isUserError());
+        assertFalse(fatal.isUserError());
+        assertFalse(except.isUserError());
+        assertFalse(warning.isUserError());
+    }
+
+    @Test
+    public void testException() {
+        fatal.setException(new Exception("foo"));
+        
+        assertTrue(fatal.isException());
+        assertTrue(fatal.isFatal());
+        assertNotNull(fatal.getException());
+        assertEquals("foo", fatal.getException().getMessage());
+        
+        except.setException(new IllegalAccessException());
+        
+        assertTrue(except.isException());
+        assertFalse(except.isFatal());
+        assertFalse(except.isError());
+        assertFalse(except.isWarning());
+    }
+
+    @Test
+    public void testGetData() {
+        assertEquals("moo", except.getData());
+    }
+
+    @Test
+    public void testAppendData() {
+        final String origin = warning.getData();
+        warning.appendData("new data!");
+        
+        assertTrue(warning.getData().startsWith(origin));
+        assertTrue(warning.getData().indexOf("new data!") > -1);
+    }
+
+    @Test
+    public void testGetLastLine() {
+        assertEquals("last line", error.getLastLine());
+    }
+
+}

test/com/dmdirc/parser/irc/Process001Test.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Process001Test {
+       
+    @Test
+    public void testDuplicate001() {
+        final TestParser tp = new TestParser();
+        
+        assertTrue(tp.getLocalClient().isFake());
+        
+        tp.injectConnectionStrings();
+        
+        assertEquals("nick", tp.getLocalClient().getNickname());
+        assertFalse(tp.getLocalClient().isFake());
+        
+        tp.injectLine(":server 001 nick2 :Crazy second 001 for you, nick2");
+        
+        assertEquals("nick2", tp.getLocalClient().getNickname());
+        assertFalse(tp.getLocalClient().isFake());
+    }
+
+}

test/com/dmdirc/parser/irc/Process004005Test.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestIErrorInfo;
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Process004005Test {
+    
+    private TestParser doCaseMappingTest(final String target, final int expected) {
+        final TestParser parser = new TestParser();
+        parser.injectConnectionStrings();
+        parser.injectLine(":server 005 nick CASEMAPPING=" + target
+                    + " :are supported by this server");
+        
+        assertEquals(expected, parser.getStringConverter().getLimit());
+        
+        return parser;
+    }
+    
+    @Test
+    public void testCaseMappingASCII() {
+        doCaseMappingTest("ascii", 0);
+        doCaseMappingTest("ASCII", 0);
+    }
+    
+    @Test
+    public void testCaseMappingRFC() {
+        doCaseMappingTest("rfc1459", 4);
+        doCaseMappingTest("RFC1459", 4);
+    }
+    
+    @Test
+    public void testCaseMappingStrict() {
+        doCaseMappingTest("strict-rfc1459", 3);
+        doCaseMappingTest("strict-RFC1459", 3);        
+    }
+    
+    @Test
+    public void testCaseMappingUnknown() {
+        final TestParser tp = doCaseMappingTest("rfc1459", 4);
+        final TestIErrorInfo tiei = new TestIErrorInfo();
+        
+        tp.getCallbackManager().addCallback(ErrorInfoListener.class, tiei);
+        
+        tp.injectLine(":server 005 nick CASEMAPPING=unknown :are supported by this server");
+        
+        assertTrue(tiei.error);
+    }
+
+}

test/com/dmdirc/parser/irc/ProcessJoinTest.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestIChannelSelfJoin;
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.interfaces.callbacks.ChannelJoinListener;
+
+import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+public class ProcessJoinTest {
+    
+    @Test
+    public void testSelfJoinChannel() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIChannelSelfJoin test = new TestIChannelSelfJoin();
+
+        parser.injectConnectionStrings();
+        parser.getCallbackManager().addCallback(ChannelSelfJoinListener.class, test);
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+
+        assertNotNull(test.channel);
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("#DMDirc_testing", test.channel.toString());
+        assertSame(parser, test.channel.getParser());
+        assertEquals(1, parser.getChannels().size());
+        assertTrue(parser.getChannels().contains(test.channel));
+        assertEquals(test.channel, parser.getChannel("#DMDirc_testing"));
+    }
+    
+    @Test
+    public void testOtherJoinChannel() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final ChannelJoinListener test = mock(ChannelJoinListener.class);
+
+        parser.injectConnectionStrings();
+        parser.getCallbackManager().addCallback(ChannelJoinListener.class, test);
+        
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":foo!bar@baz JOIN #DMDirc_testing");
+
+        verify(test).onChannelJoin(parser, parser.getChannel("#DMDirc_testing"),
+                parser.getClient("foo!bar@baz").getChannelClients().get(0));
+    }    
+
+}

test/com/dmdirc/parser/irc/ProcessModeTest.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessModeTest {
+    
+    @Test
+    public void testBasicUmodes() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":server 221 nick iw");
+
+        assertTrue(parser.getLocalClient().getModes().indexOf('i') > -1);
+        assertTrue(parser.getLocalClient().getModes().indexOf('w') > -1);
+    }
+    
+    @Test
+    public void testAlteringUmodes() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":server 221 nick iw");
+        parser.injectLine(":server MODE nick :-iw+ox");
+
+        assertTrue(parser.getLocalClient().getModes().indexOf('o') > -1);
+        assertTrue(parser.getLocalClient().getModes().indexOf('x') > -1);
+        assertEquals(-1, parser.getLocalClient().getModes().indexOf('i'));
+        assertEquals(-1, parser.getLocalClient().getModes().indexOf('w'));
+    }
+    
+    @Test
+    public void testChannelUmodes() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+
+        final IRCChannelClientInfo cci = parser.getClient("luser").getChannelClients().get(0);
+
+        parser.injectLine(":server MODE #DMDirc_testing +v luser");
+        assertEquals("+", cci.getChanModeStr(true));
+
+        parser.injectLine(":server MODE #DMDirc_testing +o luser");
+        assertEquals("ov", cci.getChanModeStr(false));
+        assertEquals("@+", cci.getChanModeStr(true));
+
+        parser.injectLine(":server MODE #DMDirc_testing +bov moo luser luser");
+        assertEquals("ov", cci.getChanModeStr(false));
+
+        parser.injectLine(":server MODE #DMDirc_testing -bov moo luser luser");
+        assertEquals("", cci.getChanModeStr(false));
+        assertEquals("", cci.getChanModeStr(true));
+    }
+    
+    @Test
+    public void testUnknownUser1() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+
+        parser.injectLine(":luser!me@my MODE #DMDirc_testing +v :moo");
+        
+        assertNotNull(parser.getClient("moo"));
+        assertEquals(1, parser.getClient("moo").getChannelCount());
+        
+        final IRCChannelClientInfo cci = parser.getClient("moo").getChannelClients().get(0);
+        
+        assertEquals("+", cci.getChanModeStr(true));        
+        assertEquals("Parser should update ident when it sees a MODE line",
+                "me", parser.getClient("luser").getUsername());
+        assertEquals("Parser should update host when it sees a MODE line",
+                "my", parser.getClient("luser").getHostname());
+    }
+    
+    @Test
+    public void testUnknownUser2() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+        parser.injectLine(":nick JOIN #DMDirc_testing2");
+        parser.injectLine(":server 353 nick = #DMDirc_testing2 :@nick +moo");
+        parser.injectLine(":server 366 nick #DMDirc_testing2 :End of /NAMES list");        
+
+        parser.injectLine(":server MODE #DMDirc_testing +v moo");
+        
+        assertNotNull(parser.getClient("moo"));
+        assertEquals(2, parser.getClient("moo").getChannelCount());
+        
+        final IRCChannelClientInfo cci = parser.getClient("moo").getChannelClients().get(0);
+        
+        assertEquals("+", cci.getChanModeStr(true));        
+    }   
+    
+    @Test
+    public void testChannelModes() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+        parser.injectLine(":server 324 nick #DMDirc_testing +Zstnl 1234");
+
+        assertEquals("1234", parser.getChannel("#DMDirc_testing").getMode('l'));
+        
+        String modes = parser.getChannel("#DMDirc_testing").getModes().split(" ")[0];
+        assertEquals(6, modes.length());
+        assertEquals('+', modes.charAt(0));
+        assertTrue(modes.indexOf('Z') > -1);
+        assertTrue(modes.indexOf('s') > -1);
+        assertTrue(modes.indexOf('t') > -1);
+        assertTrue(modes.indexOf('n') > -1);
+        assertTrue(modes.indexOf('l') > -1);
+        
+        parser.injectLine(":server MODE #DMDirc_testing :-Z");
+        
+        modes = parser.getChannel("#DMDirc_testing").getModes().split(" ")[0];
+        assertEquals(5, modes.length());
+        assertEquals('+', modes.charAt(0));
+        assertTrue(modes.indexOf('s') > -1);
+        assertTrue(modes.indexOf('t') > -1);
+        assertTrue(modes.indexOf('n') > -1);
+        assertTrue(modes.indexOf('l') > -1);        
+    }
+
+}

test/com/dmdirc/parser/irc/ProcessNamesTest.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIErrorInfo;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessNamesTest {
+    
+    @Test
+    public void testExternalNames() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIErrorInfo test = new TestIErrorInfo();
+        parser.injectConnectionStrings();
+        parser.getCallbackManager().addCallback(ErrorInfoListener.class, test);
+        
+        parser.injectLine(":server 366 nick #nonexistant :End of /NAMES list.");
+        
+        assertFalse("Should not error on unknown NAMES replies", test.error);
+    }
+    
+    @Test
+    public void testChannelUmodes() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser @+nick2 nick3");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+
+        assertEquals(1, parser.getChannels().size());
+        assertNotNull(parser.getChannel("#DMDirc_testing"));
+        assertEquals(4, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        assertNotNull(parser.getClient("luser"));
+        assertEquals(1, parser.getClient("luser").getChannelClients().size());
+
+        IRCChannelClientInfo cci = parser.getClient("luser").getChannelClients().get(0);
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
+        assertEquals("+", cci.getChanModeStr(true));
+        
+        cci = parser.getChannel("#DMDirc_testing").getChannelClient("nick2");
+        assertNotNull(cci);
+        assertEquals("@+", cci.getChanModeStr(true));
+
+        cci = parser.getChannel("#DMDirc_testing").getChannelClient("nick3");
+        assertNotNull(cci);
+        assertEquals("", cci.getChanModeStr(true));
+    }
+
+}

test/com/dmdirc/parser/irc/ProcessNickTest.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIErrorInfo;
+import com.dmdirc.harness.parser.TestINickChanged;
+import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
+import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessNickTest {
+    
+    @Test
+    public void testNickSameName() {
+        final TestParser parser = new TestParser();
+        final TestINickChanged tinc = new TestINickChanged();
+
+        parser.getCallbackManager().addCallback(NickChangeListener.class, tinc);
+        
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":nick JOIN #DMDirc_testing2");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser @+nick2 nick3");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+        parser.injectLine(":luser!lu@ser.com NICK LUSER");
+
+        assertNotNull(parser.getClient("LUSER"));
+        assertEquals(1, parser.getClient("LUSER").getChannelClients().size());
+
+        IRCChannelClientInfo cci = parser.getClient("LUSER").getChannelClients().get(0);
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
+        assertEquals("+", cci.getChanModeStr(true));
+        
+        assertSame(cci.getClient(), tinc.client);
+        assertEquals("luser", tinc.oldNick);
+    }
+    
+    @Test
+    public void testNickDifferent() {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser @+nick2 nick3");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+        parser.injectLine(":luser!lu@ser.com NICK foobar");
+
+        assertNotNull(parser.getClient("foobar"));
+        assertFalse(parser.isKnownClient("luser"));
+        assertEquals(1, parser.getClient("foobar").getChannelClients().size());
+
+        IRCChannelClientInfo cci = parser.getClient("foobar").getChannelClients().get(0);
+        assertEquals(parser.getChannel("#DMDirc_testing"), cci.getChannel());
+        assertEquals("+", cci.getChanModeStr(true));
+    }    
+    
+    @Test
+    public void testOverrideNick() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIErrorInfo info = new TestIErrorInfo();
+        
+        parser.getCallbackManager().addCallback(ErrorInfoListener.class, info);
+        parser.injectConnectionStrings();
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser @+nick2 nick3");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list");
+        parser.injectLine(":luser!lu@ser.com NICK nick3");
+
+        assertTrue("Parser should raise an error if a nick change overrides an "
+                + "existing client", info.error);
+    }
+    
+    @Test
+    public void testUnknownNick() {
+        final TestParser parser = new TestParser();
+        final TestINickChanged tinc = new TestINickChanged();
+        
+        parser.getCallbackManager().addCallback(NickChangeListener.class, tinc);
+        
+        parser.injectConnectionStrings();
+        parser.injectLine(":random!lu@ser NICK rand");
+        
+        assertNull(tinc.client);
+        assertNull(tinc.oldNick);
+    }
+
+}

test/com/dmdirc/parser/irc/ProcessPartTest.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIChannelPart;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+
+import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessPartTest {
+    
+    @Test
+    public void testNormalPart() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
+        
+        final TestIChannelPart test = new TestIChannelPart();
+        parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
+        
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        parser.injectLine(":luser!foo@barsville PART #DMDirc_testing :Bye bye, cruel world");
+        
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        assertNotNull(test.channel);
+        assertNotNull(test.cclient);
+        assertNotNull(test.reason);
+        
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("luser", test.cclient.getClient().getNickname());
+        assertEquals("Bye bye, cruel world", test.reason);
+    }
+    
+    @Test
+    public void testEmptyPart() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
+        
+        final TestIChannelPart test = new TestIChannelPart();
+        parser.getCallbackManager().addCallback(ChannelPartListener.class, test);
+        
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        parser.injectLine(":luser!foo@barsville PART #DMDirc_testing");
+        
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        assertNotNull(test.channel);
+        assertNotNull(test.cclient);
+        assertNotNull(test.reason);
+        
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("luser", test.cclient.getClient().getNickname());
+        assertEquals("", test.reason);
+    }    
+
+}

test/com/dmdirc/parser/irc/ProcessQuitTest.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIQuit;
+import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
+import com.dmdirc.parser.interfaces.callbacks.QuitListener;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessQuitTest {
+    
+    @Test
+    public void testChannelQuit() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
+        parser.injectLine(":nick JOIN #DMDirc_testing2");
+        parser.injectLine(":server 353 nick = #DMDirc_testing2 :@nick +luser2");
+        parser.injectLine(":server 366 nick #DMDirc_testing2 :End of /NAMES list.");        
+        
+        final TestIQuit test = new TestIQuit();
+        parser.getCallbackManager().addCallback(ChannelQuitListener.class, test);
+        
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        parser.injectLine(":luser!foo@barsville QUIT :Bye bye, cruel world");
+        
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing2").getChannelClients().size());
+        
+        assertNotNull(test.channel);
+        assertNotNull(test.cclient);
+        assertNotNull(test.reason);
+        
+        assertEquals(1, test.count);
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("luser", test.cclient.getClient().getNickname());
+        assertEquals("Bye bye, cruel world", test.reason);
+    }
+    
+    @Test
+    public void testGlobalQuit() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
+        parser.injectLine(":nick JOIN #DMDirc_testing2");
+        parser.injectLine(":server 353 nick = #DMDirc_testing2 :@nick +luser2");
+        parser.injectLine(":server 366 nick #DMDirc_testing2 :End of /NAMES list.");
+        
+        final TestIQuit test = new TestIQuit();
+        parser.getCallbackManager().addCallback(QuitListener.class, test);
+        
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        parser.injectLine(":luser!foo@barsville QUIT :Bye bye, cruel world");
+        
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        assertEquals(2, parser.getChannel("#DMDirc_testing2").getChannelClients().size());
+        
+        assertNotNull(test.client);
+        assertNotNull(test.reason);
+        
+        assertEquals(1, test.count);
+        assertEquals("luser", test.client.getNickname());
+        assertEquals("Bye bye, cruel world", test.reason);
+    }
+    
+    @Test
+    public void testEmptyQuit() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+
+        parser.injectConnectionStrings();
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 353 nick = #DMDirc_testing :@nick +luser");
+        parser.injectLine(":server 366 nick #DMDirc_testing :End of /NAMES list.");
+        
+        final TestIQuit test = new TestIQuit();
+        parser.getCallbackManager().addCallback(QuitListener.class, test);
+        
+        assertEquals(2, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        parser.injectLine(":luser!foo@barsville QUIT");
+        
+        assertEquals(1, parser.getChannel("#DMDirc_testing").getChannelClients().size());
+        
+        assertNotNull(test.client);
+        assertNotNull(test.reason);
+        
+        assertEquals(1, test.count);
+        assertEquals("luser", test.client.getNickname());
+        assertEquals("", test.reason);
+    }    
+
+}

test/com/dmdirc/parser/irc/ProcessTopicTest.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.harness.parser.TestIChannelTopic;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ProcessTopicTest {
+    
+    @Test
+    public void testBasicTopic() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIChannelTopic test = new TestIChannelTopic();
+        parser.injectConnectionStrings();
+        parser.getCallbackManager().addCallback(ChannelTopicListener.class, test);
+        
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 332 nick #DMDirc_testing :This be a topic");
+        parser.injectLine(":server 333 nick #DMDirc_testing Q 1207350306");
+        
+        assertTrue(test.triggered);
+        assertTrue(test.isJoin);
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("This be a topic", test.channel.getTopic());
+        assertEquals("Q", test.channel.getTopicSetter());
+        assertEquals(1207350306l, test.channel.getTopicTime());
+    }
+    
+    @Test
+    public void testTopicChange() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final TestIChannelTopic test = new TestIChannelTopic();
+        parser.injectConnectionStrings();
+        
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+        parser.injectLine(":server 332 nick #DMDirc_testing :This be a topic");
+        parser.injectLine(":server 333 nick #DMDirc_testing Q 1207350306");
+        
+        parser.getCallbackManager().addCallback(ChannelTopicListener.class, test);
+        
+        parser.injectLine(":foobar TOPIC #DMDirc_testing :New topic here");
+        
+        assertTrue(test.triggered);
+        assertFalse(test.isJoin);
+        assertEquals("#DMDirc_testing", test.channel.getName());
+        assertEquals("New topic here", test.channel.getTopic());
+        assertEquals("foobar", test.channel.getTopicSetter());
+        assertTrue(1207350306l < test.channel.getTopicTime());
+    }    
+
+}

test/com/dmdirc/parser/irc/ProcessWhoTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.harness.parser.TestParser;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
+import org.junit.Test;
+import static org.mockito.Mockito.*;
+
+public class ProcessWhoTest {
+
+    @Test
+    public void testSelfAway() throws CallbackNotFoundException {
+        final TestParser parser = new TestParser();
+        final AwayStateListener test = mock(AwayStateListener.class);
+        parser.injectConnectionStrings();
+        parser.getCallbackManager().addCallback(AwayStateListener.class, test);
+
+        parser.injectLine(":nick JOIN #DMDirc_testing");
+
+        parser.injectLine(":server 352 nick #DMDirc_testing nick2 host2 server nick2 G@ :0 rn");
+
+        verify(test, never()).onAwayState((IRCParser) anyObject(),anyBoolean(), anyString());
+
+        parser.injectLine(":server 352 nick #DMDirc_testing nick host server nick G@ :0 rn");
+
+        verify(test).onAwayState(parser, true, "");
+    }
+
+}

test/com/dmdirc/parser/irc/RegexStringListTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.dmdirc.parser.irc;
+
+import com.dmdirc.parser.common.IgnoreList;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class RegexStringListTest {
+
+    @Test
+    public void testAdd() {
+        final IgnoreList list = new IgnoreList();
+        list.add("a!b@c");
+        list.add("a!b@c");
+        list.add("A!B@c");
+
+        assertEquals(1, list.count());
+        assertEquals("a!b@c", list.get(0));
+    }
+
+    @Test
+    public void testAddAll() {
+        final List<String> tempList = new ArrayList<String>();
+        tempList.add("a!b@c");
+        tempList.add("a!b@c");
+        tempList.add("A!B@C");
+        tempList.add("Data.*");
+
+        final IgnoreList list = new IgnoreList(tempList);
+
+        assertEquals(2, list.count());
+        assertEquals("a!b@c", list.get(0));
+        assertEquals("Data.*", list.get(1));
+    }
+
+    @Test
+    public void testRmove() {
+        final List<String> tempList = new ArrayList<String>();
+        tempList.add("a!b@c");
+        tempList.add("Data.*");
+
+        final IgnoreList list = new IgnoreList(tempList);
+        list.remove(0);
+        list.remove(17);
+
+        assertEquals(1, list.count());
+        assertEquals("Data.*", list.get(0));
+    }
+
+    @Test
+    public void testClear() {
+        final List<String> tempList = new ArrayList<String>();
+        tempList.add("a!b@c");
+        tempList.add("Data.*");
+
+        final IgnoreList list = new IgnoreList(tempList);
+        list.clear();
+
+        assertEquals(0, list.count());
+    }
+
+    @Test
+    public void testMatches() {
+        final List<String> tempList = new ArrayList<String>();
+        tempList.add("a!b@c");
+        tempList.add("Data.*");
+
+        final IgnoreList list = new IgnoreList(tempList);
+
+        assertTrue(list.matches("a!b@c") == 0);
+        assertTrue(list.matches("foo") == -1);
+        assertTrue(list.matches("Dataforce") == 1);
+        assertFalse(list.matches(100, "Dataforce"));
+        assertTrue(list.matches(1, "Dataforce"));
+    }
+    
+    @Test
+    public void testGet() {
+        final IgnoreList list = new IgnoreList();
+        list.add("a!b@c");
+        assertEquals("a!b@c", list.get(0));
+        assertEquals("", list.get(7));
+    }
+
+    @Test
+    public void testSet() {
+        final IgnoreList list = new IgnoreList();
+        list.add("a!b@c");
+        list.set(0, "moo");
+        list.set(1, "bar");
+        assertEquals(1, list.count());
+        assertEquals("moo", list.get(0));
+    }
+
+}

test/com/dmdirc/parser/irc/ServerInfoTest.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ServerInfoTest {
+    
+    @Test
+    public void testHost() {
+        final ServerInfo si = new ServerInfo("host0", 5, "");
+        assertEquals("host0", si.getHost());
+        si.setHost("host1");
+        assertEquals("host1", si.getHost());
+    }
+    
+    @Test
+    public void testPort() {
+        final ServerInfo si = new ServerInfo("host0", 5, "");
+        assertEquals(5, si.getPort());
+        si.setPort(65530);
+        assertEquals(65530, si.getPort());
+    }
+    
+    @Test
+    public void testPassword() {
+        final ServerInfo si = new ServerInfo("host0", 5, "pass1");
+        assertEquals("pass1", si.getPassword());
+        si.setPassword("pass2");
+        assertEquals("pass2", si.getPassword());
+    }
+    
+    @Test
+    public void testSSL() {
+        final ServerInfo si = new ServerInfo("host0", 5, "pass1");
+        assertFalse(si.getSSL());
+        si.setSSL(true);
+        assertTrue(si.getSSL());
+    }
+    
+    @Test
+    public void testUseSocks() {
+        final ServerInfo si = new ServerInfo("host0", 5, "pass1");
+        assertFalse(si.getUseSocks());
+        si.setUseSocks(true);
+        assertTrue(si.getUseSocks());
+    }
+    
+    @Test
+    public void testProxyHost() {
+        final ServerInfo si = new ServerInfo("host0", 5, "pass1");
+        si.setProxyHost("foo");
+        assertEquals("foo", si.getProxyHost());
+    }
+    
+    @Test
+    public void testProxyPort() {
+        final ServerInfo si = new ServerInfo("host0", 5, "pass1");
+        si.setProxyPort(1024);
+        assertEquals(1024, si.getProxyPort());
+    }
+    
+}