tunit

IRCSharp.Tests/State/Casemap.cs

···
 public class Casemap
 {
     [Test]
-    public void Rfc1459()
+    public async Task Rfc1459()
     {
         var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Rfc1459, @"ÀTEST[]~\");
-        Assert.That(lower).IsEqualTo("Àtest{}^|");
+        await Assert.That(lower).IsEqualTo("Àtest{}^|");
     }
 
     [Test]
-    public void Ascii()
+    public async Task Ascii()
     {
         var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Ascii, @"ÀTEST[]~\");
-        Assert.That(lower).IsEqualTo(@"Àtest[]~\");
+        await Assert.That(lower).IsEqualTo(@"Àtest[]~\");
     }
 
     [Test]
-    public void CommandJoin()
+    public async Task CommandJoin()
     {
         var server = new Server("test");
         server.Parse(new Line("001 nickname"));
         server.Parse(new Line(":Nickname JOIN #Chan"));
         server.Parse(new Line(":Other JOIN #Chan"));
 
-        Assert.That(server.Users).ContainsKey("nickname");
-        Assert.That(server.Users).ContainsKey("nickname");
-        Assert.That(server.Users).DoesNotContainKey("Nickname");
-        Assert.That(server.Users).ContainsKey("other");
-        Assert.That(server.Users).DoesNotContainKey("Other");
-        Assert.That(server.Channels).ContainsKey("#chan");
-        Assert.That(server.Channels).DoesNotContainKey("#Chan");
+        await Assert.That(server.Users).ContainsKey("nickname");
+        await Assert.That(server.Users).ContainsKey("nickname");
+        await Assert.That(server.Users).DoesNotContainKey("Nickname");
+        await Assert.That(server.Users).ContainsKey("other");
+        await Assert.That(server.Users).DoesNotContainKey("Other");
+        await Assert.That(server.Channels).ContainsKey("#chan");
+        await Assert.That(server.Channels).DoesNotContainKey("#Chan");
 
         var channel = server.Channels["#chan"];
-        Assert.That(channel.Name).IsEqualTo("#Chan");
+        await Assert.That(channel.Name).IsEqualTo("#Chan");
     }
 
     [Test]
-    public void CommandNick()
+    public async Task CommandNick()
     {
         var server = new Server("test");
         server.Parse(new Line("001 nickname"));
         server.Parse(new Line(":nickname JOIN #chan"));
         var user = server.Users["nickname"];
         server.Parse(new Line(":nickname NICK NewNickname"));
-        Assert.That(server.Users).HasCount(1);
-        Assert.That(server.Users).ContainsKey("newnickname");
-        Assert.That(user.NickName).IsEqualTo("NewNickname");
-        Assert.That(user.NickNameLower).IsEqualTo("newnickname");
-        Assert.That(server.NickName).IsEqualTo("NewNickname");
-        Assert.That(server.NickNameLower).IsEqualTo("newnickname");
+        await Assert.That(server.Users).HasCount(1);
+        await Assert.That(server.Users).ContainsKey("newnickname");
+        await Assert.That(user.NickName).IsEqualTo("NewNickname");
+        await Assert.That(user.NickNameLower).IsEqualTo("newnickname");
+        await Assert.That(server.NickName).IsEqualTo("NewNickname");
+        await Assert.That(server.NickNameLower).IsEqualTo("newnickname");
     }
 }

IRCSharp.Tests/State/ISupport.cs

···
 // ReSharper disable InconsistentNaming
 // ReSharper disable StringLiteralTypo
+
 namespace IRCSharp.Tests.State;
 
 public class ISupport
···
     }
 
     [Test]
-    public void ChanModes()
+    public async Task ChanModes()
     {
-        CollectionAssert.AreEqual(new List<string> {"b"}, _server.ISupport.ChanModes.ListModes);
-        CollectionAssert.AreEqual(new List<string> {"k"}, _server.ISupport.ChanModes.SettingBModes);
-        CollectionAssert.AreEqual(new List<string> {"l"}, _server.ISupport.ChanModes.SettingCModes);
-        CollectionAssert.AreEqual(new List<string>
-        {
-            "i",
-            "m",
-            "n",
-            "p",
-            "s",
-            "t"
-        }, _server.ISupport.ChanModes.SettingDModes);
+        await Assert.That(_server.ISupport.ChanModes.ListModes).IsEqualTo(["b"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingBModes).IsEqualTo(["k"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingCModes).IsEqualTo(["l"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingDModes).IsEqualTo(["i", "m", "n", "p", "s", "t"]);
 
         _server.Parse(new Line("005 * CHANMODES=a,b,c,d *"));
 
-        CollectionAssert.AreEqual(new List<string> {"a"}, _server.ISupport.ChanModes.ListModes);
-        CollectionAssert.AreEqual(new List<string> {"b"}, _server.ISupport.ChanModes.SettingBModes);
-        CollectionAssert.AreEqual(new List<string> {"c"}, _server.ISupport.ChanModes.SettingCModes);
-        CollectionAssert.AreEqual(new List<string> {"d"}, _server.ISupport.ChanModes.SettingDModes);
+        await Assert.That(_server.ISupport.ChanModes.ListModes).IsEqualTo(["a"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingBModes).IsEqualTo(["b"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingCModes).IsEqualTo(["c"]);
+        await Assert.That(_server.ISupport.ChanModes.SettingDModes).IsEqualTo(["d"]);
     }
 
     [Test]
-    public void Prefix()
+    public async Task Prefix()
     {
-        CollectionAssert.AreEqual(new List<string> {"o", "v"}, _server.ISupport.Prefix.Modes);
-        CollectionAssert.AreEqual(new List<string> {"@", "+"}, _server.ISupport.Prefix.Prefixes);
+        await Assert.That(_server.ISupport.Prefix.Modes).IsEqualTo(["o", "v"]);
+        await Assert.That(_server.ISupport.Prefix.Prefixes).IsEqualTo(["@", "+"]);
 
-        Assert.AreEqual("@", _server.ISupport.Prefix.FromMode("o"));
-        Assert.IsNull(_server.ISupport.Prefix.FromMode("a"));
-        Assert.AreEqual("o", _server.ISupport.Prefix.FromPrefix("@"));
-        Assert.IsNull(_server.ISupport.Prefix.FromPrefix("&"));
+        await Assert.That(_server.ISupport.Prefix.FromMode("o")).IsEqualTo("@");
+        await Assert.That(_server.ISupport.Prefix.FromMode("a")).IsNull();
+        await Assert.That(_server.ISupport.Prefix.FromPrefix("@")).IsEqualTo("o");
+        await Assert.That(_server.ISupport.Prefix.FromPrefix("&")).IsNull();
 
         _server.Parse(new Line("005 * PREFIX=(qaohv)~&@%+ *"));
-        CollectionAssert.AreEqual(new List<string>
-        {
-            "q",
-            "a",
-            "o",
-            "h",
-            "v"
-        }, _server.ISupport.Prefix.Modes);
-        CollectionAssert.AreEqual(new List<string>
-        {
-            "~",
-            "&",
-            "@",
-            "%",
-            "+"
-        }, _server.ISupport.Prefix.Prefixes);
-        Assert.AreEqual("&", _server.ISupport.Prefix.FromMode("a"));
-        Assert.AreEqual("a", _server.ISupport.Prefix.FromPrefix("&"));
+        await Assert.That(_server.ISupport.Prefix.Modes).IsEqualTo(["q", "a", "o", "h", "v"]);
+        await Assert.That(_server.ISupport.Prefix.Prefixes).IsEqualTo(["~", "&", "@", "%", "+",]);
+        
+        await Assert.That(_server.ISupport.Prefix.FromMode("a")).IsEqualTo("&");
+        await Assert.That(_server.ISupport.Prefix.FromPrefix("&")).IsEqualTo("a");
     }
 
     [Test]
-    public void ChanTypes()
+    public async Task ChanTypes()
     {
-        CollectionAssert.AreEqual(new List<string> {"#"}, _server.ISupport.ChanTypes);
+        await Assert.That(_server.ISupport.ChanTypes).IsEqualTo(["#"]);
         _server.Parse(new Line("005 * CHANTYPES=#& *"));
-        CollectionAssert.AreEqual(new List<string> {"#", "&"}, _server.ISupport.ChanTypes);
+        await Assert.That(_server.ISupport.ChanTypes).IsEqualTo(["#", "&"]);
     }
 
     [Test]
-    public void Modes()
+    public async Task Modes()
     {
-        Assert.AreEqual(3, _server.ISupport.Modes);
+        await Assert.That(_server.ISupport.Modes).IsEqualTo(3);
 
         _server.Parse(new Line("005 * MODES *"));
-        Assert.AreEqual(-1, _server.ISupport.Modes);
+        await Assert.That(_server.ISupport.Modes).IsEqualTo(-1);
 
         _server.Parse(new Line("005 * MODES=5 *"));
-        Assert.AreEqual(5, _server.ISupport.Modes);
+        await Assert.That(_server.ISupport.Modes).IsEqualTo(5);
     }
 
     [Test]
-    public void Rfc1459()
+    public async Task Rfc1459()
     {
-        Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
+        await Assert.That(_server.ISupport.CaseMapping).IsEqualTo(IRCStates.Casemap.CaseMapping.Rfc1459);
         _server.Parse(new Line("005 * CASEMAPPING=rfc1459 *"));
-        Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
+        await Assert.That(_server.ISupport.CaseMapping).IsEqualTo(IRCStates.Casemap.CaseMapping.Rfc1459);
         var lower = _server.CaseFold(@"ÀTEST[]~\");
-        Assert.AreEqual("Àtest{}^|", lower);
+        await Assert.That(lower).IsEqualTo("Àtest{}^|");
     }
 
     [Test]
-    public void Ascii()
+    public async Task Ascii()
     {
         _server.Parse(new Line("005 * CASEMAPPING=ascii *"));
-        Assert.AreEqual(IRCStates.Casemap.CaseMapping.Ascii, _server.ISupport.CaseMapping);
+        await Assert.That(_server.ISupport.CaseMapping).IsEqualTo(IRCStates.Casemap.CaseMapping.Ascii);
         var lower = _server.CaseFold(@"ÀTEST[]~\");
-        Assert.AreEqual(@"Àtest[]~\", lower);
+        await Assert.That(lower).IsEqualTo(@"Àtest[]~\");
     }
 
     [Test]
-    public void FallbackToRfc1459()
+    public async Task FallbackToRfc1459()
     {
         _server.Parse(new Line("005 * CASEMAPPING=nonexistent *"));
-        Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
+        await Assert.That(_server.ISupport.CaseMapping).IsEqualTo(IRCStates.Casemap.CaseMapping.Rfc1459);
         var lower = _server.CaseFold(@"ÀTEST[]~\");
-        Assert.AreEqual("Àtest{}^|", lower);
+        await Assert.That(lower).IsEqualTo("Àtest{}^|");
     }
 
     [Test]
-    public void Network()
+    public async Task Network()
     {
-        Assert.IsNull(_server.ISupport.Network);
+        await Assert.That(_server.ISupport.Network).IsNull();
         _server.Parse(new Line("005 * NETWORK=testnet *"));
-        Assert.AreEqual("testnet", _server.ISupport.Network);
+        await Assert.That(_server.ISupport.Network).IsEqualTo("testnet");
     }
 
     [Test]
-    public void StatusMsg()
+    public async Task StatusMsg()
     {
-        CollectionAssert.AreEqual(new List<string>(), _server.ISupport.StatusMsg);
+        await Assert.That(_server.ISupport.StatusMsg).IsEmpty();
         _server.Parse(new Line("005 * STATUSMSG=&@ *"));
-        CollectionAssert.AreEqual(new List<string> {"&", "@"}, _server.ISupport.StatusMsg);
+        await Assert.That(_server.ISupport.StatusMsg).IsEqualTo(["&", "@"]);
     }
 
     [Test]
-    public void CallerId()
+    public async Task CallerId()
     {
-        Assert.IsNull(_server.ISupport.CallerId);
+        await Assert.That(_server.ISupport.CallerId).IsNull();
 
         _server.Parse(new Line("005 * CALLERID=U *"));
-        Assert.AreEqual("U", _server.ISupport.CallerId);
+        await Assert.That(_server.ISupport.CallerId).IsEqualTo("U");
 
         _server.Parse(new Line("005 * CALLERID *"));
-        Assert.AreEqual("g", _server.ISupport.CallerId);
+        await Assert.That(_server.ISupport.CallerId).IsEqualTo("g");
     }
 
     [Test]
-    public void Excepts()
+    public async Task Excepts()
     {
-        Assert.IsNull(_server.ISupport.Excepts);
+        await Assert.That(_server.ISupport.Excepts).IsNull();
 
         _server.Parse(new Line("005 * EXCEPTS=U *"));
-        Assert.AreEqual("U", _server.ISupport.Excepts);
+        await Assert.That(_server.ISupport.Excepts).IsEqualTo("U");
 
         _server.Parse(new Line("005 * EXCEPTS *"));
-        Assert.AreEqual("e", _server.ISupport.Excepts);
+        await Assert.That(_server.ISupport.Excepts).IsEqualTo("e");
     }
 
     [Test]
-    public void Invex()
+    public async Task Invex()
     {
-        Assert.IsNull(_server.ISupport.Invex);
+        await Assert.That(_server.ISupport.Invex).IsNull();
 
         _server.Parse(new Line("005 * INVEX=U *"));
-        Assert.AreEqual("U", _server.ISupport.Invex);
+        await Assert.That(_server.ISupport.Invex).IsEqualTo("U");
 
         _server.Parse(new Line("005 * INVEX *"));
-        Assert.AreEqual("I", _server.ISupport.Invex);
+        await Assert.That(_server.ISupport.Invex).IsEqualTo("I");
     }
 
     [Test]
-    public void Whox()
+    public async Task Whox()
     {
-        Assert.IsFalse(_server.ISupport.Whox);
+        await Assert.That(_server.ISupport.Whox).IsFalse();
 
         _server.Parse(new Line("005 * WHOX *"));
-        Assert.IsTrue(_server.ISupport.Whox);
+        await Assert.That(_server.ISupport.Whox).IsTrue();
     }
 
     [Test]
-    public void Monitor()
+    public async Task Monitor()
     {
-        Assert.IsNull(_server.ISupport.Monitor);
+        await Assert.That(_server.ISupport.Monitor).IsNull();
 
         _server.Parse(new Line("005 * MONITOR=123 *"));
-        Assert.AreEqual(123, _server.ISupport.Monitor);
+        await Assert.That(_server.ISupport.Monitor).IsEqualTo(123);
 
         _server.Parse(new Line("005 * MONITOR *"));
-        Assert.AreEqual(-1, _server.ISupport.Monitor);
+        await Assert.That(_server.ISupport.Monitor).IsEqualTo(-1);
     }
 
     [Test]
-    public void Watch()
+    public async Task Watch()
     {
-        Assert.IsNull(_server.ISupport.Watch);
+        await Assert.That(_server.ISupport.Watch).IsNull();
 
         _server.Parse(new Line("005 * WATCH=123 *"));
-        Assert.AreEqual(123, _server.ISupport.Watch);
+        await Assert.That(_server.ISupport.Watch).IsEqualTo(123);
 
         _server.Parse(new Line("005 * WATCH *"));
-        Assert.AreEqual(-1, _server.ISupport.Watch);
+        await Assert.That(_server.ISupport.Watch).IsEqualTo(-1);
     }
 }

IRCSharp.Tests/State/Mode.cs

···
 // ReSharper disable StringLiteralTypo
+
 namespace IRCSharp.Tests.State;
 
 public class Mode
···
     }
 
     [Test]
-    public void UModeAdd()
+    public async Task UModeAdd()
     {
         _server.Parse(new Line("MODE nickname +i"));
-        CollectionAssert.AreEqual(new List<string> {"i"}, _server.Modes);
+        await Assert.That(_server.Modes).IsEqualTo(["i"]);
     }
 
     [Test]
-    public void UModeRemove()
+    public async Task UModeRemove()
     {
         _server.Parse(new Line("MODE nickname +i"));
         _server.Parse(new Line("MODE nickname -i"));
-        CollectionAssert.AreEqual(new List<string>(), _server.Modes);
+        await Assert.That(_server.Modes).IsEmpty();
     }
 
     [Test]
-    public void PrefixAdd()
+    public async Task PrefixAdd()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +ov nickname nickname"));
···
         var user        = _server.Users["nickname"];
         var channel     = _server.Channels["#chan"];
         var channelUser = channel.Users[user.NickNameLower];
-        CollectionAssert.AreEqual(new List<string> {"o", "v"}, channelUser.Modes);
+        await Assert.That(channelUser.Modes).IsEqualTo(["o", "v"]);
     }
 
     [Test]
-    public void PrefixRemove()
+    public async Task PrefixRemove()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +ov nickname nickname"));
···
         var user        = _server.Users["nickname"];
         var channel     = _server.Channels["#chan"];
         var channelUser = channel.Users[user.NickNameLower];
-        CollectionAssert.AreEqual(new List<string>(), channelUser.Modes);
+        await Assert.That(channelUser.Modes).IsEmpty();
     }
 
     [Test]
-    public void ChannelListAdd()
+    public async Task ChannelListAdd()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +b asd!*@*"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new List<string> {"asd!*@*"}, channel.ListModes["b"]);
+        await Assert.That(channel.ListModes["b"]).IsEqualTo(["asd!*@*"]);
     }
 
     [Test]
-    public void ChannelListRemove()
+    public async Task ChannelListRemove()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +b asd!*@*"));
         _server.Parse(new Line("MODE #chan -b asd!*@*"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, List<string>>(), channel.ListModes);
+        await Assert.That(channel.ListModes).IsEmpty();
     }
 
     [Test]
-    public void ChannelTypeBAdd()
+    public async Task ChannelTypeBAdd()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +k password"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "password"}}, channel.Modes);
+        await Assert.That(channel.Modes).IsEqualTo(new Dictionary<string, string> { { "k", "password" } });
     }
 
     [Test]
-    public void ChannelTypeBRemove()
+    public async Task ChannelTypeBRemove()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +k password"));
         _server.Parse(new Line("MODE #chan -k *"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
+        await Assert.That(channel.Modes).IsEmpty();
     }
 
     [Test]
-    public void ChannelTypeCAdd()
+    public async Task ChannelTypeCAdd()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +l 100"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"l", "100"}}, channel.Modes);
+        await Assert.That(channel.Modes).IsEqualTo(new Dictionary<string, string> { { "l", "100" } });
     }
 
     [Test]
-    public void ChannelTypeCRemove()
+    public async Task ChannelTypeCRemove()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +l 100"));
         _server.Parse(new Line("MODE #chan -l"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
+        await Assert.That(channel.Modes).IsEmpty();
     }
 
     [Test]
-    public void ChannelTypeDAdd()
+    public async Task ChannelTypeDAdd()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +i"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}}, channel.Modes);
+        await Assert.That(channel.Modes).IsEqualTo(new Dictionary<string, string> { { "i", null } });
     }
 
     [Test]
-    public void ChannelTypeDRemove()
+    public async Task ChannelTypeDRemove()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("MODE #chan +i"));
         _server.Parse(new Line("MODE #chan -i"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
+        await Assert.That(channel.Modes).IsEmpty();
     }
 
     [Test]
-    public void ChannelNumeric()
+    public async Task ChannelNumeric()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("324 * #chan +bkli *!*@* pass 10"));
+        var channel = _server.Channels["#chan"];
 
-        var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "pass"}, {"l", "10"}, {"i", null}},
-            channel.Modes);
-        CollectionAssert.AreEqual(new List<string> {"*!*@*"}, channel.ListModes["b"]);
+        var expectedModes = new Dictionary<string, string> { { "k", "pass" }, { "l", "10" }, { "i", null } };
+        await Assert.That(channel.Modes).IsEqualTo(expectedModes);
+        await Assert.That(channel.ListModes["b"]).IsEqualTo(["*!*@*"]);
     }
 
     [Test]
-    public void ChannelNumericWithoutPlus()
+    public async Task ChannelNumericWithoutPlus()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("324 * #chan il 10"));
 
         var channel = _server.Channels["#chan"];
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}, {"l", "10"}}, channel.Modes);
+        await Assert.That(channel.Modes).IsEqualTo(new Dictionary<string, string> { { "i", null }, { "l", "10" } });
     }
 
     [Test]
-    public void UserNumeric()
+    public async Task UserNumeric()
     {
         _server.Parse(new Line("221 * +iw"));
-        CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes);
+        await Assert.That(_server.Modes).IsEqualTo(["i", "w"]);
     }
 
     [Test]
-    public void UserNumericWithoutPlus()
+    public async Task UserNumericWithoutPlus()
     {
         _server.Parse(new Line("221 * iw"));
-        CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes);
+        await Assert.That(_server.Modes).IsEqualTo(["i", "w"]);
     }
 }

IRCSharp.Tests/State/Motd.cs

···
 namespace IRCSharp.Tests.State;
 
-[TestClass]
 public class Motd
 {
     [Test]
-    public void MessageOfTheDay()
+    public async Task MessageOfTheDay()
     {
         var server = new Server("test");
         server.Parse(new Line("001 nickname"));
···
         server.Parse(new Line("372 * :first line of motd"));
         server.Parse(new Line("372 * :second line of motd"));
 
-        CollectionAssert.AreEqual(new List<string> {"start of motd", "first line of motd", "second line of motd"},
-            server.Motd);
+        await Assert.That(server.Motd).IsEqualTo(["start of motd", "first line of motd", "second line of motd"]);
     }
 }

IRCSharp.Tests/State/Sasl.cs

···
 namespace IRCSharp.Tests.State;
 
-[TestClass]
 public class Sasl
 {
-    private Server _server;
+    private readonly Server _server = new("test");
 
-    [TestInitialize]
-    public void TestInitialize()
+    public Sasl()
     {
-        _server = new Server("test");
         _server.Parse(new Line("900 * nick!user@host account"));
     }
 
     [Test]
-    public void LoggedIn()
+    public async Task LoggedIn()
     {
-        Assert.AreEqual("nick", _server.NickName);
-        Assert.AreEqual("user", _server.UserName);
-        Assert.AreEqual("host", _server.HostName);
-        Assert.AreEqual("account", _server.Account);
+        await Assert.That(_server.NickName).IsEqualTo("nick");
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsEqualTo("host");
+        await Assert.That(_server.Account).IsEqualTo("account");
     }
 
     [Test]
-    public void LoggedOut()
+    public async Task LoggedOut()
     {
         _server.Parse(new Line("901 * nick1!user1@host1"));
 
-        Assert.AreEqual("nick1", _server.NickName);
-        Assert.AreEqual("user1", _server.UserName);
-        Assert.AreEqual("host1", _server.HostName);
-        Assert.IsTrue(string.IsNullOrEmpty(_server.Account));
+        await Assert.That(_server.NickName).IsEqualTo("nick1");
+        await Assert.That(_server.UserName).IsEqualTo("user1");
+        await Assert.That(_server.HostName).IsEqualTo("host1");
+        await Assert.That(_server.Account).IsEmpty();
     }
 }

IRCSharp.Tests/State/User.cs

···
-namespace IRCSharp.Tests.State;
+using System.Threading.Tasks;
+
+namespace IRCSharp.Tests.State;
 
-[TestClass]
 public class User
 {
-    private Server _server;
+    private readonly Server _server = new("test");
 
-    [TestInitialize]
-    public void TestInitialize()
+    public User()
     {
-        _server = new Server("test");
         _server.Parse(new Line("001 nickname"));
     }
 
     [Test]
-    public void Welcome()
+    public async Task Welcome()
     {
-        Assert.AreEqual("test", _server.Name);
-        Assert.AreEqual("nickname", _server.NickName);
+        await Assert.That(_server.Name).IsEqualTo("test");
+        await Assert.That(_server.NickName).IsEqualTo("nickname");
     }
 
     [Test]
-    public void NicknameChange()
+    public async Task NicknameChange()
     {
         _server.Parse(new Line(":nickname NICK nickname2"));
-        Assert.AreEqual("nickname2", _server.NickName);
+        await Assert.That(_server.NickName).IsEqualTo("nickname2");
 
         _server.Parse(new Line(":nickname2 JOIN #chan"));
         _server.Parse(new Line(":other JOIN #chan"));
-        Assert.IsTrue(_server.Users.ContainsKey("other"));
+        await Assert.That(_server.Users).ContainsKey("other");
 
         _server.Parse(new Line(":other NICK other2"));
-        Assert.IsFalse(_server.Users.ContainsKey("other"));
-        Assert.IsTrue(_server.Users.ContainsKey("other2"));
+        await Assert.That(_server.Users).DoesNotContainKey("other");
+        await Assert.That(_server.Users).ContainsKey("other2");
     }
 
     [Test]
-    public void HostmaskJoinBoth()
+    public async Task HostmaskJoinBoth()
     {
         _server.Parse(new Line(":nickname!user@host JOIN #chan"));
-        Assert.AreEqual("user", _server.UserName);
-        Assert.AreEqual("host", _server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsEqualTo("host");
 
         _server.Parse(new Line(":other!user@host JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.AreEqual("user", user.UserName);
-        Assert.AreEqual("host", user.HostName);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(user.HostName).IsEqualTo("host");
     }
 
     [Test]
-    public void HostmaskJoinUser()
+    public async Task HostmaskJoinUser()
     {
         _server.Parse(new Line(":nickname!user JOIN #chan"));
-        Assert.AreEqual("user", _server.UserName);
-        Assert.IsNull(_server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsNull();
 
         _server.Parse(new Line(":other!user JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.AreEqual("user", user.UserName);
-        Assert.IsNull(user.HostName);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(user.HostName).IsNull();
     }
 
     [Test]
-    public void HostmaskJoinHost()
+    public async Task HostmaskJoinHost()
     {
         _server.Parse(new Line(":nickname@host JOIN #chan"));
-        Assert.IsNull(_server.UserName);
-        Assert.AreEqual("host", _server.HostName);
+        await Assert.That(_server.UserName).IsNull();
+        await Assert.That(_server.HostName).IsEqualTo("host");
 
         _server.Parse(new Line(":other@host JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.IsNull(user.UserName);
-        Assert.AreEqual("host", user.HostName);
+        await Assert.That(user.UserName).IsNull();
+        await Assert.That(user.HostName).IsEqualTo("host");
     }
 
     [Test]
-    public void ExtendedJoinWithoutExtendedJoin()
+    public async Task ExtendedJoinWithoutExtendedJoin()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
-        Assert.IsNull(_server.Account);
-        Assert.IsNull(_server.RealName);
+        await Assert.That(_server.Account).IsNull();
+        await Assert.That(_server.RealName).IsNull();
 
         _server.Parse(new Line(":other JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.IsNull(user.Account);
-        Assert.IsNull(user.RealName);
+        await Assert.That(user.Account).IsNull();
+        await Assert.That(user.RealName).IsNull();
     }
 
     [Test]
-    public void ExtendedJoinWithAccount()
+    public async Task ExtendedJoinWithAccount()
     {
         _server.Parse(new Line(":nickname JOIN #chan acc :realname"));
-        Assert.AreEqual("acc", _server.Account);
-        Assert.AreEqual("realname", _server.RealName);
+        await Assert.That(_server.Account).IsEqualTo("acc");
+        await Assert.That(_server.RealName).IsEqualTo("realname");
 
         _server.Parse(new Line(":other JOIN #chan acc2 :realname2"));
         var user = _server.Users["other"];
-        Assert.AreEqual("acc2", user.Account);
-        Assert.AreEqual("realname2", user.RealName);
+        await Assert.That(user.Account).IsEqualTo("acc2");
+        await Assert.That(user.RealName).IsEqualTo("realname2");
     }
 
     [Test]
-    public void ExtendedJoinWithoutAccount()
+    public async Task ExtendedJoinWithoutAccount()
     {
         _server.Parse(new Line(":nickname JOIN #chan * :realname"));
-        Assert.AreEqual("", _server.Account);
-        Assert.AreEqual("realname", _server.RealName);
+        await Assert.That(_server.Account).IsEqualTo("");
+        await Assert.That(_server.RealName).IsEqualTo("realname");
 
         _server.Parse(new Line(":other JOIN #chan * :realname2"));
         var user = _server.Users["other"];
-        Assert.AreEqual("", user.Account);
-        Assert.AreEqual("realname2", user.RealName);
+        await Assert.That(user.Account).IsEqualTo("");
+        await Assert.That(user.RealName).IsEqualTo("realname2");
     }
 
     [Test]
-    public void AccountNotifyWithAccount()
+    public async Task AccountNotifyWithAccount()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":nickname ACCOUNT acc"));
-        Assert.AreEqual("acc", _server.Account);
+        await Assert.That(_server.Account).IsEqualTo("acc");
 
         _server.Parse(new Line(":other JOIN #chan"));
         _server.Parse(new Line(":other ACCOUNT acc2"));
         var user = _server.Users["other"];
-        Assert.AreEqual("acc2", user.Account);
+        await Assert.That(user.Account).IsEqualTo("acc2");
     }
 
     [Test]
-    public void AccountNotifyWithoutAccount()
+    public async Task AccountNotifyWithoutAccount()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":nickname ACCOUNT *"));
-        Assert.AreEqual("", _server.Account);
+        await Assert.That(_server.Account).IsEqualTo("");
 
         _server.Parse(new Line(":other JOIN #chan"));
         _server.Parse(new Line(":other ACCOUNT *"));
         var user = _server.Users["other"];
-        Assert.AreEqual("", user.Account);
+        await Assert.That(user.Account).IsEqualTo("");
     }
 
     [Test]
-    public void HostmaskPrivmsgBoth()
+    public async Task HostmaskPrivmsgBoth()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":nickname!user@host PRIVMSG #chan :hi"));
-        Assert.AreEqual("user", _server.UserName);
-        Assert.AreEqual("host", _server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsEqualTo("host");
 
         _server.Parse(new Line(":other!user@host PRIVMSG #chan :hi"));
         var user = _server.Users["other"];
-        Assert.AreEqual("user", user.UserName);
-        Assert.AreEqual("host", user.HostName);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(user.HostName).IsEqualTo("host");
     }
 
     [Test]
-    public void HostmaskPrivmsgUser()
+    public async Task HostmaskPrivmsgUser()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":nickname!user PRIVMSG #chan :hi"));
-        Assert.AreEqual("user", _server.UserName);
-        Assert.IsNull(_server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsNull();
 
         _server.Parse(new Line(":other!user PRIVMSG #chan :hi"));
         var user = _server.Users["other"];
-        Assert.AreEqual("user", user.UserName);
-        Assert.IsNull(user.HostName);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(user.HostName).IsNull();
     }
 
     [Test]
-    public void HostmaskPrivmsgHost()
+    public async Task HostmaskPrivmsgHost()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":nickname@host PRIVMSG #chan :hi"));
-        Assert.IsNull(_server.UserName);
-        Assert.AreEqual("host", _server.HostName);
+        await Assert.That(_server.UserName).IsNull();
+        await Assert.That(_server.HostName).IsEqualTo("host");
 
         _server.Parse(new Line(":other@host PRIVMSG #chan :hi"));
         var user = _server.Users["other"];
-        Assert.IsNull(user.UserName);
-        Assert.AreEqual("host", user.HostName);
+        await Assert.That(user.UserName).IsNull();
+        await Assert.That(user.HostName).IsEqualTo("host");
     }
 
     [Test]
-    public void VisibleHostWithoutUsername()
+    public async Task VisibleHostWithoutUsername()
     {
         _server.Parse(new Line("396 * hostname"));
-        Assert.IsNull(_server.UserName);
-        Assert.AreEqual("hostname", _server.HostName);
+        await Assert.That(_server.UserName).IsNull();
+        await Assert.That(_server.HostName).IsEqualTo("hostname");
     }
 
     [Test]
-    public void VisibleHostWithUsername()
+    public async Task VisibleHostWithUsername()
     {
         _server.Parse(new Line("396 * username@hostname"));
-        Assert.AreEqual("username", _server.UserName);
-        Assert.AreEqual("hostname", _server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("username");
+        await Assert.That(_server.HostName).IsEqualTo("hostname");
     }
 
     [Test]
-    public void Who()
+    public async Task Who()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":other JOIN #chan"));
         _server.Parse(new Line("352 * #chan user host * nickname * :0 real"));
         _server.Parse(new Line("352 * #chan user2 host2 * other * :0 real2"));
 
-        Assert.AreEqual("user", _server.UserName);
-        Assert.AreEqual("host", _server.HostName);
-        Assert.AreEqual("real", _server.RealName);
+        await Assert.That(_server.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsEqualTo("host");
+        await Assert.That(_server.RealName).IsEqualTo("real");
 
         var user = _server.Users["other"];
-        Assert.AreEqual("user2", user.UserName);
-        Assert.AreEqual("host2", user.HostName);
-        Assert.AreEqual("real2", user.RealName);
+        await Assert.That(user.UserName).IsEqualTo("user2");
+        await Assert.That(user.HostName).IsEqualTo("host2");
+        await Assert.That(user.RealName).IsEqualTo("real2");
     }
 
     [Test]
-    public void Chghost()
+    public async Task Chghost()
     {
         _server.Parse(new Line(":nickname!user@host JOIN #chan"));
         _server.Parse(new Line(":nickname CHGHOST u h"));
-        Assert.AreEqual("u", _server.UserName);
-        Assert.AreEqual("h", _server.HostName);
+        await Assert.That(_server.UserName).IsEqualTo("u");
+        await Assert.That(_server.HostName).IsEqualTo("h");
 
         _server.Parse(new Line(":other!user2@host2 JOIN #chan"));
         _server.Parse(new Line(":other CHGHOST u2 h2"));
         var user = _server.Users["other"];
-        Assert.AreEqual("u2", user.UserName);
-        Assert.AreEqual("h2", user.HostName);
+        await Assert.That(user.UserName).IsEqualTo("u2");
+        await Assert.That(user.HostName).IsEqualTo("h2");
     }
 
     [Test]
-    public void Whois()
+    public async Task Whois()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line("311 * nickname u h * :r"));
-        Assert.AreEqual("u", _server.UserName);
-        Assert.AreEqual("h", _server.HostName);
-        Assert.AreEqual("r", _server.RealName);
+        await Assert.That(_server.UserName).IsEqualTo("u");
+        await Assert.That(_server.HostName).IsEqualTo("h");
+        await Assert.That(_server.RealName).IsEqualTo("r");
 
         _server.Parse(new Line(":other JOIN #chan"));
         _server.Parse(new Line(":other CHGHOST u2 h2"));
         _server.Parse(new Line("311 * other u2 h2 * :r2"));
         var user = _server.Users["other"];
-        Assert.AreEqual("u2", user.UserName);
-        Assert.AreEqual("h2", user.HostName);
-        Assert.AreEqual("r2", user.RealName);
+        await Assert.That(user.UserName).IsEqualTo("u2");
+        await Assert.That(user.HostName).IsEqualTo("h2");
+        await Assert.That(user.RealName).IsEqualTo("r2");
     }
 
     [Test]
-    public void AwaySet()
+    public async Task AwaySet()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":other JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.IsNull(_server.Away);
-        Assert.IsNull(user.Away);
+        await Assert.That(_server.Away).IsNull();
+        await Assert.That(user.Away).IsNull();
 
         _server.Parse(new Line(":nickname AWAY :bye bye"));
         _server.Parse(new Line(":other AWAY :ich geh weg"));
-        Assert.AreEqual("bye bye", _server.Away);
-        Assert.AreEqual("ich geh weg", user.Away);
+        await Assert.That(_server.Away).IsEqualTo("bye bye");
+        await Assert.That(user.Away).IsEqualTo("ich geh weg");
     }
 
     [Test]
-    public void AwayUnset()
+    public async Task AwayUnset()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":other JOIN #chan"));
···
         _server.Parse(new Line(":other AWAY"));
 
         var user = _server.Users["other"];
-        Assert.IsNull(_server.Away);
-        Assert.IsNull(user.Away);
+        await Assert.That(_server.Away).IsNull();
+        await Assert.That(user.Away).IsNull();
     }
 
     [Test]
-    public void Setname()
+    public async Task Setname()
     {
         _server.Parse(new Line(":nickname JOIN #chan"));
         _server.Parse(new Line(":other JOIN #chan"));
         var user = _server.Users["other"];
-        Assert.IsNull(user.RealName);
-        Assert.IsNull(_server.RealName);
+        await Assert.That(user.RealName).IsNull();
+        await Assert.That(_server.RealName).IsNull();
 
         _server.Parse(new Line(":nickname SETNAME :new now know how"));
         _server.Parse(new Line(":other SETNAME :tyrannosaurus hex"));
-        Assert.AreEqual("new now know how", _server.RealName);
-        Assert.AreEqual("tyrannosaurus hex", user.RealName);
+        await Assert.That(_server.RealName).IsEqualTo("new now know how");
+        await Assert.That(user.RealName).IsEqualTo("tyrannosaurus hex");
     }
 }

IRCSharp.Tests/State/Who.cs

···
 // ReSharper disable StringLiteralTypo
 namespace IRCSharp.Tests.State;
 
-[TestClass]
 public class Who
 {
-    private Server _server;
+    private readonly Server _server = new("test");
 
-    [TestInitialize]
-    public void TestInitialize()
+    public Who()
     {
-        _server = new Server("test");
         _server.Parse(new Line("001 nickname"));
         _server.Parse(new Line(":nickname JOIN #chan"));
     }
 
     [Test]
-    public void WhoResponse()
+    public async Task WhoResponse()
     {
         _server.Parse(new Line("352 * #chan user host server nickname * :0 real"));
         var user = _server.Users["nickname"];
 
-        Assert.AreEqual("user", user.UserName);
-        Assert.AreEqual("host", _server.HostName);
-        Assert.AreEqual("real", user.RealName);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(_server.HostName).IsEqualTo("host");
+        await Assert.That(user.RealName).IsEqualTo("real");
 
-        Assert.AreEqual(user.UserName, _server.UserName);
-        Assert.AreEqual(user.HostName, _server.HostName);
-        Assert.AreEqual(user.RealName, _server.RealName);
+        await Assert.That(_server.UserName).IsEqualTo(user.UserName);
+        await Assert.That(_server.HostName).IsEqualTo(user.HostName);
+        await Assert.That(_server.RealName).IsEqualTo(user.RealName);
     }
 
     [Test]
-    public void Whox()
+    public async Task Whox()
     {
         _server.Parse(new Line($"354 * {Server.WhoType} user realip host nickname account :real"));
         var user = _server.Users["nickname"];
 
-        Assert.AreEqual("user", user.UserName);
-        Assert.AreEqual("host", user.HostName);
-        Assert.AreEqual("real", user.RealName);
-        Assert.AreEqual("account", user.Account);
+        await Assert.That(user.UserName).IsEqualTo("user");
+        await Assert.That(user.HostName).IsEqualTo("host");
+        await Assert.That(user.RealName).IsEqualTo("real");
+        await Assert.That(user.Account).IsEqualTo("account");
 
-        Assert.AreEqual(user.UserName, _server.UserName);
-        Assert.AreEqual(user.HostName, _server.HostName);
-        Assert.AreEqual(user.RealName, _server.RealName);
-        Assert.AreEqual(user.Account, _server.Account);
+        await Assert.That(_server.UserName).IsEqualTo(user.UserName);
+        await Assert.That(_server.HostName).IsEqualTo(user.HostName);
+        await Assert.That(_server.RealName).IsEqualTo(user.RealName);
+        await Assert.That(_server.Account).IsEqualTo(user.Account);
     }
 
     [Test]
-    public void WhoxNoAccount()
+    public async Task WhoxNoAccount()
     {
         _server.Parse(new Line($"354 * {Server.WhoType} user realip host nickname 0 :real"));
         var user = _server.Users["nickname"];
 
-        Assert.IsNull(user.Account);
-        Assert.AreEqual(user.Account, _server.Account);
+        await Assert.That(user.Account).IsNull();
+        await Assert.That(_server.Account).IsEqualTo(user.Account);
     }
 }

IRCSharp.Tests/Tokenization/StatefulDecoder.cs

···
     public async Task Partial()
     {
         var lines = _decoder.Push("PRIVMSG ");
-        Assert.That(lines).IsEmpty();
+        await Assert.That(lines).IsEmpty();
 
         lines = _decoder.Push("#channel hello\r\n");
-        Assert.That(lines).HasCount(1);
+        await Assert.That(lines).HasCount(1);
 
         var line = new Line("PRIVMSG #channel hello");
         await Assert.That(lines).Contains(line);

IRCSharp.Tests/Tokenization/StatefulEncoder.cs

···
     private readonly IRCTokens.StatefulEncoder _encoder = new();
 
     [Test]
-    public void Push()
+    public async Task Push()
     {
         var line = new Line("PRIVMSG #channel hello");
         _encoder.Push(line);
-        Assert.AreEqual("PRIVMSG #channel hello\r\n", _encoder.Pending());
+        await Assert.That(_encoder.Pending()).IsEqualTo("PRIVMSG #channel hello\r\n");
     }
 
     [Test]
-    public void PopPartial()
+    public async Task PopPartial()
     {
         var line = new Line("PRIVMSG #channel hello");
         _encoder.Push(line);
         _encoder.Pop("PRIVMSG #channel hello".Length);
-        Assert.AreEqual("\r\n", _encoder.Pending());
+        await Assert.That(_encoder.Pending()).IsEqualTo("\r\n");
     }
 
     [Test]
-    public void TestPopReturned()
+    public async Task TestPopReturned()
     {
         var line = new Line("PRIVMSG #channel hello");
         _encoder.Push(line);
         _encoder.Push(line);
         var lines = _encoder.Pop("PRIVMSG #channel hello\r\n".Length);
-        Assert.AreEqual(1, lines.Count);
-        Assert.AreEqual(line, lines[0]);
+        await Assert.That(lines).HasCount(1);
+        await Assert.That(lines[0]).IsEqualTo(line);
     }
 
     [Test]
-    public void PopNoneReturned()
+    public async Task PopNoneReturned()
     {
         var line = new Line("PRIVMSG #channel hello");
         _encoder.Push(line);
         var lines = _encoder.Pop(1);
-        Assert.AreEqual(0, lines.Count);
+        await Assert.That(lines).IsEmpty();
     }
 
     [Test]
-    public void PopMultipleLines()
+    public async Task PopMultipleLines()
     {
         var line1 = new Line("PRIVMSG #channel1 hello");
         _encoder.Push(line1);
···
         _encoder.Push(line2);
 
         var lines = _encoder.Pop(_encoder.Pending().Length);
-        Assert.AreEqual(2, lines.Count);
-        Assert.AreEqual(string.Empty, _encoder.Pending());
+        await Assert.That(lines).HasCount(2);
+        await Assert.That(_encoder.Pending()).IsEmpty();
     }
 
     [Test]
-    public void Clear()
+    public async Task Clear()
     {
         _encoder.Push(new Line("PRIVMSG #channel hello"));
         _encoder.Clear();
-        Assert.AreEqual(string.Empty, _encoder.Pending());
+        await Assert.That(_encoder.Pending()).IsEmpty();
     }
 
     [Test]
-    public void EncodingIso8859()
+    public async Task EncodingIso8859()
     {
         var encoder = new IRCTokens.StatefulEncoder {Encoding = Encoding.Latin1};
         encoder.Push(new Line("PRIVMSG #channel :hello Ç"));
-        CollectionAssert.AreEqual(Encoding.Latin1.GetBytes("PRIVMSG #channel :hello Ç\r\n"), encoder.PendingBytes);
+        await Assert.That(encoder.PendingBytes).IsEqualTo(Encoding.Latin1.GetBytes("PRIVMSG #channel :hello Ç\r\n"));
     }
 }

IRCSharp.Tests/Tokenization/Tokenization.cs

···
 public class Tokenization
 {
     [Test]
-    public void TagsMissing()
+    public async Task TagsMissing()
     {
         var line = new Line("PRIVMSG #channel");
-        Assert.IsNull(line.Tags);
+        await Assert.That(line.Tags).IsNull();
     }
 
     [Test]
-    public void TagsMissingValue()
+    public async Task TagsMissingValue()
     {
         var line = new Line("@id= PRIVMSG #channel");
-        Assert.AreEqual(string.Empty, line.Tags["id"]);
+        await Assert.That(line.Tags["id"]).IsEmpty();
     }
 
     [Test]
-    public void TagsMissingEqual()
+    public async Task TagsMissingEqual()
     {
         var line = new Line("@id PRIVMSG #channel");
-        Assert.IsNull(line.Tags["id"]);
+        await Assert.That(line.Tags["id"]).IsNull();
     }
 
     [Test]
-    public void TagsUnescape()
+    public async Task TagsUnescape()
     {
         var line = new Line(@"@id=1\\\:\r\n\s2 PRIVMSG #channel");
-        Assert.AreEqual("1\\;\r\n 2", line.Tags["id"]);
+        await Assert.That(line.Tags["id"]).IsEqualTo("1\\;\r\n 2");
     }
 
     [Test]
-    public void TagsOverlap()
+    public async Task TagsOverlap()
     {
         var line = new Line(@"@id=1\\\s\\s PRIVMSG #channel");
-        Assert.AreEqual(@"1\ \s", line.Tags["id"]);
+        await Assert.That(line.Tags["id"]).IsEqualTo(@"1\ \s");
     }
 
     [Test]
-    public void TagsLoneEndSlash()
+    public async Task TagsLoneEndSlash()
     {
         var line = new Line("@id=1\\ PRIVMSG #channel");
-        Assert.AreEqual("1", line.Tags["id"]);
+        await Assert.That(line.Tags["id"]).IsEqualTo("1");
     }
 
     [Test]
-    public void SourceWithoutTags()
+    public async Task SourceWithoutTags()
     {
         var line = new Line(":nick!user@host PRIVMSG #channel");
-        Assert.AreEqual("nick!user@host", line.Source);
+        await Assert.That(line.Source).IsEqualTo("nick!user@host");
     }
 
     [Test]
-    public void SourceWithTags()
+    public async Task SourceWithTags()
     {
         var line = new Line("@id=123 :nick!user@host PRIVMSG #channel");
-        Assert.AreEqual("nick!user@host", line.Source);
+        await Assert.That(line.Source).IsEqualTo("nick!user@host");
     }
 
     [Test]
-    public void SourceMissingWithoutTags()
+    public async Task SourceMissingWithoutTags()
     {
         var line = new Line("PRIVMSG #channel");
-        Assert.IsNull(line.Source);
+        await Assert.That(line.Source).IsNull();
     }
 
     [Test]
-    public void SourceMissingWithTags()
+    public async Task SourceMissingWithTags()
     {
         var line = new Line("@id=123 PRIVMSG #channel");
-        Assert.IsNull(line.Source);
+        await Assert.That(line.Source).IsNull();
     }
 
     [Test]
-    public void Command()
+    public async Task Command()
     {
         var line = new Line("privmsg #channel");
-        Assert.AreEqual("PRIVMSG", line.Command);
+        await Assert.That(line.Command).IsEqualTo("PRIVMSG");
     }
 
     [Test]
-    public void ParamsTrailing()
+    public async Task ParamsTrailing()
     {
         var line = new Line("PRIVMSG #channel :hello world");
-        CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params);
+        await Assert.That(line.Params).IsEqualTo(["#channel", "hello world"]);
     }
 
     [Test]
-    public void ParamsOnlyTrailing()
+    public async Task ParamsOnlyTrailing()
     {
         var line = new Line("PRIVMSG :hello world");
-        CollectionAssert.AreEqual(new List<string> {"hello world"}, line.Params);
+        await Assert.That(line.Params).IsEqualTo(["hello world"]);
     }
 
     [Test]
-    public void ParamsMissing()
+    public async Task ParamsMissing()
     {
         var line = new Line("PRIVMSG");
-        Assert.AreEqual("PRIVMSG", line.Command);
-        CollectionAssert.AreEqual(new List<string>(), line.Params);
+        await Assert.That(line.Command).IsEqualTo("PRIVMSG");
+        await Assert.That(line.Params).IsEqualTo([]);
     }
 
     [Test]
-    public void AllTokens()
+    public async Task AllTokens()
     {
         var line = new Line("@id=123 :nick!user@host PRIVMSG #channel :hello world");
-        CollectionAssert.AreEqual(new Dictionary<string, string> {{"id", "123"}}, line.Tags);
-        Assert.AreEqual("nick!user@host", line.Source);
-        Assert.AreEqual("PRIVMSG", line.Command);
-        CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params);
+        await Assert.That(line.Tags).IsEqualTo(new Dictionary<string, string> {{"id", "123"}});
+        await Assert.That(line.Source).IsEqualTo("nick!user@host");
+        await Assert.That(line.Command).IsEqualTo("PRIVMSG");
+        await Assert.That(line.Params).IsEqualTo(["#channel", "hello world"]);
     }
 
     [Test]
-    public void NulByte()
+    public async Task NulByte()
     {
         var decoder = new IRCTokens.StatefulDecoder();
-        var bytes = ":nick!user@host PRIVMSG #channel :hello"u8.ToArray()
-            .Concat("\0"u8.ToArray())
-            .Concat("world"u8.ToArray())
-            .ToArray();
-        var line = decoder.Push(bytes, bytes.Length).First();
+        var bytes   = ":nick!user@host PRIVMSG #channel :hello\0world"u8;
+        var line    = decoder.Push(bytes.ToArray(), bytes.Length).First();
 
-        CollectionAssert.AreEqual(new List<string> {"#channel", "hello"}, line.Params);
+        await Assert.That(line.Params).IsEqualTo(["#channel", "hello"]);
     }
 }