Add more tests, ran resharper formatting tool

IrcStates/Channel.cs

···
     {
         public string Name { get; set; }
         public string NameLower { get; set; }
-        public Dictionary<string, User> Users { get; set; }
+        public Dictionary<string, ChannelUser> Users { get; set; }
         public string Topic { get; set; }
         public string TopicSetter { get; set; }
         public DateTime TopicTime { get; set; }
···
 
         public void SetName(string name, string nameLower)
         {
-            Name = name;
+            Name      = name;
             NameLower = nameLower;
         }
 
···
         {
             if (listMode)
             {
-                if (!ListModes.ContainsKey(ch))
-                {
-                    ListModes[ch] = new List<string>();
-                }
+                if (!ListModes.ContainsKey(ch)) ListModes[ch] = new List<string>();
 
-                if (ListModes[ch].Contains(param))
-                {
-                    ListModes[ch].Add(param ?? string.Empty);
-                }
+                if (ListModes[ch].Contains(param)) ListModes[ch].Add(param ?? string.Empty);
             }
             else
             {
···
                 if (ListModes[ch].Contains(param))
                 {
                     ListModes[ch].Remove(param);
-                    if (!ListModes[ch].Any())
-                    {
-                        ListModes.Remove(ch);
-                    }
+                    if (!ListModes[ch].Any()) ListModes.Remove(ch);
                 }
             }
             else if (Modes.ContainsKey(ch))

IrcStates/ChannelUser.cs

···
+using System.Collections.Generic;
+
+namespace IrcStates
+{
+    public class ChannelUser
+    {
+        public List<string> Modes { get; set; }
+    }
+}

IrcStates/Emit.cs

···
         public string Text { get; set; }
         public List<string> Tokens { get; set; }
         public bool Finished { get; set; }
+        public bool Self { get; set; }
         public bool SelfSource { get; set; }
         public bool SelfTarget { get; set; }
         public Tests.User User { get; set; }

IrcStates/ISupport.cs

···
 // ReSharper disable InconsistentNaming
+
 namespace IrcStates
 {
     public class ISupport

IrcStates/Numeric.cs

···
         public const string RPL_QUIETLIST = "728";
         public const string RPL_ENDOFQUIETLIST = "729";
 
+        public const string RPL_LOGGEDIN = "900";
+        public const string RPL_LOGGEDOUT = "901";
         public const string RPL_SASLSUCCESS = "903";
         public const string ERR_SASLFAIL = "904";
         public const string ERR_SASLTOOLONG = "905";

IrcStates/ServerDisconnectedException.cs

···
 {
     public class ServerDisconnectedException : Exception
     {
-
     }
 }

IrcStates/ServerException.cs

···
 {
     public class ServerException : Exception
     {
-
     }
 }

IrcStates/Tests/Channel.cs

···
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using IrcTokens;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace IrcStates.Tests
 {
     [TestClass]
     public class Channel
     {
+        private Server _server;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            _server = new Server("test");
+            _server.ParseTokens(new Line("001 nickname"));
+            _server.ParseTokens(new Line(":nickname JOIN #chan"));
+        }
+
+        [TestMethod]
+        public void JoinSelf()
+        {
+            Assert.IsTrue(_server.Channels.ContainsKey("#chan"));
+            Assert.IsTrue(_server.Users.ContainsKey("nickname"));
+            Assert.AreEqual(1, _server.Channels.Count);
+            Assert.AreEqual(1, _server.Users.Count);
+
+            var user = _server.Users["nickname"];
+            var chan = _server.Channels["#chan"];
+            Assert.IsTrue(chan.Users.ContainsKey(user.NickNameLower));
+            var chanUser = chan.Users[user.NickNameLower];
+            CollectionAssert.AreEqual(new List<string> {chan.NameLower}, user.Channels.ToList());
+        }
+
+        [TestMethod]
+        public void JoinOther()
+        {
+            _server.ParseTokens(new Line(":other JOIN #chan"));
+
+            Assert.AreEqual(2, _server.Users.Count);
+            Assert.IsTrue(_server.Users.ContainsKey("other"));
+
+            var channel = _server.Channels["#chan"];
+            Assert.AreEqual(2, channel.Users.Count);
+
+            var user = _server.Users["other"];
+            CollectionAssert.AreEqual(new List<string> {channel.NameLower}, user.Channels.ToList());
+        }
+
+        [TestMethod]
+        public void PartSelf()
+        {
+            _server.ParseTokens(new Line(":nickname PART #chan"));
+
+            Assert.AreEqual(0, _server.Users.Count);
+            Assert.AreEqual(0, _server.Channels.Count);
+        }
+
+        [TestMethod]
+        public void PartOther()
+        {
+            _server.ParseTokens(new Line(":other JOIN #chan"));
+            _server.ParseTokens(new Line(":other PART #chan"));
+
+            var user     = _server.Users["nickname"];
+            var channel  = _server.Channels["#chan"];
+            var chanUser = channel.Users[user.NickNameLower];
+
+            Assert.AreEqual(channel.NameLower, user.Channels.Single());
+            CollectionAssert.AreEqual(new Dictionary<string, IrcStates.User> {{"nickname", user}}, _server.Users);
+            CollectionAssert.AreEqual(new Dictionary<string, IrcStates.Channel> {{"#chan", channel}}, _server.Channels);
+            CollectionAssert.AreEqual(new Dictionary<string, ChannelUser> {{"nickname", chanUser}}, channel.Users);
+        }
+
+        [TestMethod]
+        public void KickSelf()
+        {
+            _server.ParseTokens(new Line(":nickname KICK #chan nickname"));
+
+            Assert.AreEqual(0, _server.Users.Count);
+            Assert.AreEqual(0, _server.Channels.Count);
+        }
+
+        [TestMethod]
+        public void KickOther()
+        {
+            _server.ParseTokens(new Line(":other JOIN #chan"));
+            _server.ParseTokens(new Line(":nickname KICK #chan other"));
+
+            var user     = _server.Users["nickname"];
+            var channel  = _server.Channels["#chan"];
+            var chanUser = channel.Users[user.NickNameLower];
+
+            Assert.AreEqual(1, _server.Users.Count);
+            Assert.AreEqual(1, _server.Channels.Count);
+            Assert.AreEqual(channel.NameLower, user.Channels.Single());
+            CollectionAssert.AreEqual(new Dictionary<string, ChannelUser> {{user.NickNameLower, chanUser}},
+                channel.Users);
+        }
+
+        [TestMethod]
+        public void TopicText()
+        {
+            _server.ParseTokens(new Line("332 * #chan :test"));
+            Assert.AreEqual("test", _server.Channels["#chan"].Topic);
+        }
+
+        [TestMethod]
+        public void TopicSetByAt()
+        {
+            var dt = DateTimeOffset.FromUnixTimeSeconds(1584023277).DateTime;
+            _server.ParseTokens(new Line("333 * #chan other 1584023277"));
+
+            var channel = _server.Channels["#chan"];
+
+            Assert.AreEqual("other", channel.TopicSetter);
+            Assert.AreEqual(dt, channel.TopicTime);
+        }
+
+        [TestMethod]
+        public void TopicCommand()
+        {
+            _server.ParseTokens(new Line("TOPIC #chan :hello there"));
+            Assert.AreEqual("hello there", _server.Channels["#chan"].Topic);
+        }
+
+        [TestMethod]
+        public void CreationDate()
+        {
+            _server.ParseTokens(new Line("329 * #chan 1584041889"));
+            Assert.AreEqual(DateTimeOffset.FromUnixTimeSeconds(1584041889).DateTime, _server.Channels["#chan"].Created);
+        }
+
+        [TestMethod]
+        public void NamesCommand()
+        {
+            _server.ParseTokens(new Line("353 * * #chan :nickname @+other"));
+            Assert.IsTrue(_server.Users.ContainsKey("nickname"));
+            Assert.IsTrue(_server.Users.ContainsKey("other"));
+
+            var user      = _server.Users["other"];
+            var channel   = _server.Channels["#chan"];
+            var chanUser1 = channel.Users[user.NickNameLower];
+            var chanUser2 = channel.Users[_server.NickNameLower];
+
+            CollectionAssert.AreEqual(
+                new Dictionary<string, ChannelUser>
+                {
+                    {user.NickNameLower, chanUser1}, {_server.NickNameLower, chanUser2}
+                }, channel.Users);
+            CollectionAssert.AreEqual(new List<string> {"o", "v"}, chanUser1.Modes);
+            Assert.AreEqual(channel.NameLower, user.Channels.Single());
+        }
+
+        [TestMethod]
+        public void UserhostInNames()
+        {
+            _server.ParseTokens(new Line("353 * * #chan :nickname!user@host other@user2@host2"));
+            Assert.AreEqual("user", _server.UserName);
+            Assert.AreEqual("host", _server.HostName);
+
+            var user = _server.Users["other"];
+            Assert.AreEqual("user2", user.HostName);
+            Assert.AreEqual("host2", user.HostName);
+        }
+
+        [TestMethod]
+        public void NickAfterJoin()
+        {
+            var user     = _server.Users["nickname"];
+            var channel  = _server.Channels["#chan"];
+            var chanUser = channel.Users[user.NickNameLower];
+            _server.ParseTokens(new Line(":nickname NICK nickname2"));
+            CollectionAssert.AreEqual(new Dictionary<string, ChannelUser> {{user.NickNameLower, chanUser}},
+                channel.Users);
+        }
     }
 }

IrcStates/Tests/Emit.cs

···
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using IrcTokens;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace IrcStates.Tests
 {
     [TestClass]
     public class Emit
     {
+        private Server _server;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            _server = new Server("test");
+            _server.ParseTokens(new Line("001 nickname"));
+        }
+
+        [TestMethod]
+        public void EmitJoin()
+        {
+            var emit = _server.ParseTokens(new Line(":nickname JOIN #chan"));
+
+            Assert.AreEqual("JOIN", emit.Command);
+            Assert.IsTrue(emit.Self);
+            Assert.AreEqual(_server.Users["nickname"], emit.User);
+            Assert.AreEqual(_server.Channels["#chan"], emit.Channel);
+
+            emit = _server.ParseTokens(new Line(":other JOIN #chan"));
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("JOIN", emit.Command);
+            Assert.IsFalse(emit.Self);
+            Assert.AreEqual(_server.Users["other"], emit.User);
+            Assert.AreEqual(_server.Channels["#chan"], emit.Channel);
+        }
+
+        [TestMethod]
+        public void EmitPrivmsg()
+        {
+            _server.ParseTokens(new Line(":nickname JOIN #chan"));
+            var emit = _server.ParseTokens(new Line(":nickname PRIVMSG #chan :hello"));
+
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("PRIVMSG", emit.Command);
+            Assert.AreEqual("hello", emit.Text);
+            Assert.IsTrue(emit.SelfSource);
+            Assert.AreEqual(_server.Users["nickname"], emit.User);
+            Assert.AreEqual(_server.Channels["#chan"], emit.Channel);
+
+            _server.ParseTokens(new Line(":other JOIN #chan"));
+            emit = _server.ParseTokens(new Line(":other PRIVMSG #chan :hello2"));
+
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("PRIVMSG", emit.Command);
+            Assert.AreEqual("hello2", emit.Text);
+            Assert.IsFalse(emit.SelfSource);
+            Assert.AreEqual(_server.Users["other"], emit.User);
+            Assert.AreEqual(_server.Channels["#chan"], emit.Channel);
+        }
+
+        [TestMethod]
+        public void EmitPrivmsgNoJoin()
+        {
+            _server.ParseTokens(new Line(":nickname JOIN #chan"));
+            var emit = _server.ParseTokens(new Line(":other PRIVMSG #chan :hello"));
+
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("PRIVMSG", emit.Command);
+            Assert.AreEqual("hello", emit.Text);
+            Assert.IsFalse(emit.SelfSource);
+            Assert.IsNotNull(emit.User);
+
+            var channel = _server.Channels["#chan"];
+            Assert.AreEqual(channel, emit.Channel);
+        }
+
+        [TestMethod]
+        public void EmitKick()
+        {
+            _server.ParseTokens(new Line(":nickname JOIN #chan"));
+
+            var user    = _server.Users["nickname"];
+            var channel = _server.Channels["#chan"];
+            _server.ParseTokens(new Line(":other JOIN #chan"));
+            var userOther = _server.Users["other"];
+            var emit      = _server.ParseTokens(new Line(":nickname KICK #chan other :reason"));
+
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("KICK", emit.Command);
+            Assert.AreEqual("reason", emit.Text);
+            Assert.IsTrue(emit.SelfSource);
+            Assert.AreEqual(user, emit.UserSource);
+            Assert.AreEqual(userOther, emit.UserTarget);
+            Assert.AreEqual(channel, emit.Channel);
+        }
+
+        [TestMethod]
+        public void EmitMode()
+        {
+            var emit = _server.ParseTokens(new Line("MODE nickname x+i-i+wi-wi"));
+
+            Assert.IsNotNull(emit);
+            Assert.AreEqual("MODE", emit.Command);
+            Assert.IsTrue(emit.SelfTarget);
+            CollectionAssert.AreEqual(new List<string>
+            {
+                "+x",
+                "+i",
+                "-i",
+                "+w",
+                "+i",
+                "-w",
+                "-i"
+            }, emit.Tokens);
+        }
     }
 }

IrcStates/Tests/ISupport.cs

···
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 // ReSharper disable InconsistentNaming
 
 namespace IrcStates.Tests

IrcTokens/Line.cs

···
 
             if (Params != null && Params.Any())
             {
-                var last = Params[^1];
+                var last        = Params[^1];
                 var withoutLast = Params.SkipLast(1).ToList();
 
                 foreach (var p in withoutLast)

IrcTokens/StatefulEncoder.cs

···
         {
             var sent = PendingBytes.Take(byteCount).Count(c => c == '\n');
 
-            PendingBytes   = PendingBytes.Skip(byteCount).ToArray();
-            
+            PendingBytes = PendingBytes.Skip(byteCount).ToArray();
+
             var sentLines = _bufferedLines.Take(sent).ToList();
             _bufferedLines = _bufferedLines.Skip(sent).ToList();
 

IrcTokens/Tests/Data/JoinModel.cs

···
 
         public class Test
         {
-            [YamlMember(Alias = "desc")]
-            public string Description { get; set; }
+            [YamlMember(Alias = "desc")] public string Description { get; set; }
 
             public Atoms Atoms { get; set; }