irctokens
/
ircsharp
4
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

switch to global usings

This commit is contained in:
Ben Harris 2024-03-26 16:10:54 -04:00
parent a7b45f1e36
commit 325b3bb30d
21 changed files with 1739 additions and 1814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Examples/States/Client.cs
View File

@ -29,7 +29,7 @@ internal class Client(string host, int port, string nick)
while (true) while (true)
{ {
while (_encoder.PendingBytes.Any()) while (_encoder.PendingBytes.Length != 0)
{ {
foreach (var line in _encoder.Pop(_socket.Send(_encoder.PendingBytes))) foreach (var line in _encoder.Pop(_socket.Send(_encoder.PendingBytes)))
Console.WriteLine($"> {line.Format()}"); Console.WriteLine($"> {line.Format()}");

10
IRCSharp.Tests/IRCSharp.Tests.csproj
View File

@ -17,6 +17,16 @@
<ProjectReference Include="..\IRCTokens\IRCTokens.csproj" /> <ProjectReference Include="..\IRCTokens\IRCTokens.csproj" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<Using Include="IRCTokens" />
<Using Include="IRCStates" />
<Using Include="System" />
<Using Include="System.Collections.Generic" />
<Using Include="System.Linq" />
<Using Include="System.Text" />
<Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
</ItemGroup>
<ItemGroup> <ItemGroup>
<None Update="Tokenization\Data\msg-join.yaml"> <None Update="Tokenization\Data\msg-join.yaml">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

221
IRCSharp.Tests/State/Cap.cs
View File

@ -1,131 +1,126 @@
using System.Collections.Generic; namespace IRCSharp.Tests.State;
using IRCStates;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Cap
{ {
[TestClass] private Server _server;
public class Cap
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void LSOneLine()
{ {
_server = new("test"); Assert.IsFalse(_server.HasCap);
} CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
_server.Parse(new("CAP * LS :a b"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps);
}
[TestMethod] [TestMethod]
public void LSOneLine() public void LsTwoLines()
{ {
Assert.IsFalse(_server.HasCap); _server.Parse(new("CAP * LS * :a b"));
CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps); CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
_server.Parse(new("CAP * LS :a b")); _server.Parse(new("CAP * LS :c"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps); Assert.IsTrue(_server.AvailableCaps.ContainsKey("a"));
} Assert.IsTrue(_server.AvailableCaps.ContainsKey("b"));
Assert.IsTrue(_server.AvailableCaps.ContainsKey("c"));
}
[TestMethod] [TestMethod]
public void LsTwoLines() public void LsValues()
{ {
_server.Parse(new("CAP * LS * :a b")); _server.Parse(new("CAP * LS :a b= c=1"));
CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps); CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", "1"}},
_server.Parse(new("CAP * LS :c")); _server.AvailableCaps);
Assert.IsTrue(_server.AvailableCaps.ContainsKey("a")); }
Assert.IsTrue(_server.AvailableCaps.ContainsKey("b"));
Assert.IsTrue(_server.AvailableCaps.ContainsKey("c"));
}
[TestMethod] [TestMethod]
public void LsValues() public void ACKOneLine()
{ {
_server.Parse(new("CAP * LS :a b= c=1")); _server.Parse(new("CAP * LS :a b"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", "1"}}, _server.Parse(new("CAP * ACK :a b"));
_server.AvailableCaps); CollectionAssert.AreEqual(new List<string> {"a", "b"}, _server.AgreedCaps);
} }
[TestMethod] [TestMethod]
public void ACKOneLine() public void ACKTwoLines()
{ {
_server.Parse(new("CAP * LS :a b")); _server.Parse(new("CAP * LS :a b c"));
_server.Parse(new("CAP * ACK :a b")); _server.Parse(new("CAP * ACK * :a b"));
CollectionAssert.AreEqual(new List<string> {"a", "b"}, _server.AgreedCaps); _server.Parse(new("CAP * ACK :c"));
} CollectionAssert.AreEqual(new List<string> {"a", "b", "c"}, _server.AgreedCaps);
}
[TestMethod] [TestMethod]
public void ACKTwoLines() public void ACKNotLs()
{ {
_server.Parse(new("CAP * LS :a b c")); _server.Parse(new("CAP * LS a"));
_server.Parse(new("CAP * ACK * :a b")); _server.Parse(new("CAP * ACK b"));
_server.Parse(new("CAP * ACK :c")); CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
CollectionAssert.AreEqual(new List<string> {"a", "b", "c"}, _server.AgreedCaps); }
}
[TestMethod] [TestMethod]
public void ACKNotLs() public void NewNoLs()
{ {
_server.Parse(new("CAP * LS a")); _server.Parse(new("CAP * NEW :a"));
_server.Parse(new("CAP * ACK b")); CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}}, _server.AvailableCaps);
CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps); }
}
[TestMethod] [TestMethod]
public void NewNoLs() public void NewOneLine()
{ {
_server.Parse(new("CAP * NEW :a")); _server.Parse(new("CAP * LS :a"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}}, _server.AvailableCaps); _server.Parse(new("CAP * NEW :b"));
} CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps);
}
[TestMethod] [TestMethod]
public void NewOneLine() public void NewTwoLines()
{ {
_server.Parse(new("CAP * LS :a")); _server.Parse(new("CAP * LS :a"));
_server.Parse(new("CAP * NEW :b")); _server.Parse(new("CAP * NEW :b c"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps); CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", ""}},
} _server.AvailableCaps);
}
[TestMethod] [TestMethod]
public void NewTwoLines() public void DelNotAcked()
{ {
_server.Parse(new("CAP * LS :a")); _server.Parse(new("CAP * DEL a"));
_server.Parse(new("CAP * NEW :b c")); }
CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", ""}},
_server.AvailableCaps);
}
[TestMethod] [TestMethod]
public void DelNotAcked() public void DELOneLS()
{ {
_server.Parse(new("CAP * DEL a")); _server.Parse(new("CAP * LS :a"));
} _server.Parse(new("CAP * ACK :a"));
_server.Parse(new("CAP * DEL :a"));
CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
}
[TestMethod] [TestMethod]
public void DELOneLS() public void DelTwoLs()
{ {
_server.Parse(new("CAP * LS :a")); _server.Parse(new("CAP * LS :a b"));
_server.Parse(new("CAP * ACK :a")); _server.Parse(new("CAP * ACK :a b"));
_server.Parse(new("CAP * DEL :a")); _server.Parse(new("CAP * DEL :a"));
CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps); CollectionAssert.AreEqual(new Dictionary<string, string> {{"b", ""}}, _server.AvailableCaps);
CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps); CollectionAssert.AreEqual(new List<string> {"b"}, _server.AgreedCaps);
} }
[TestMethod] [TestMethod]
public void DelTwoLs() public void DelTwoDel()
{ {
_server.Parse(new("CAP * LS :a b")); _server.Parse(new("CAP * LS :a b"));
_server.Parse(new("CAP * ACK :a b")); _server.Parse(new("CAP * ACK :a b"));
_server.Parse(new("CAP * DEL :a")); _server.Parse(new("CAP * DEL :a b"));
CollectionAssert.AreEqual(new Dictionary<string, string> {{"b", ""}}, _server.AvailableCaps); CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
CollectionAssert.AreEqual(new List<string> {"b"}, _server.AgreedCaps); CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
}
[TestMethod]
public void DelTwoDel()
{
_server.Parse(new("CAP * LS :a b"));
_server.Parse(new("CAP * ACK :a b"));
_server.Parse(new("CAP * DEL :a b"));
CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
}
} }
} }

92
IRCSharp.Tests/State/Casemap.cs
View File

@ -1,58 +1,54 @@
using IRCStates; namespace IRCSharp.Tests.State;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Casemap
{ {
[TestClass] [TestMethod]
public class Casemap public void Rfc1459()
{ {
[TestMethod] var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Rfc1459, @"ÀTEST[]~\");
public void Rfc1459() Assert.AreEqual("Àtest{}^|", lower);
{ }
var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Rfc1459, @"ÀTEST[]~\");
Assert.AreEqual("Àtest{}^|", lower);
}
[TestMethod] [TestMethod]
public void Ascii() public void Ascii()
{ {
var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Ascii, @"ÀTEST[]~\"); var lower = IRCStates.Casemap.CaseFold(IRCStates.Casemap.CaseMapping.Ascii, @"ÀTEST[]~\");
Assert.AreEqual(@"Àtest[]~\", lower); Assert.AreEqual(@"Àtest[]~\", lower);
} }
[TestMethod] [TestMethod]
public void CommandJoin() public void CommandJoin()
{ {
var server = new Server("test"); var server = new Server("test");
server.Parse(new("001 nickname")); server.Parse(new("001 nickname"));
server.Parse(new(":Nickname JOIN #Chan")); server.Parse(new(":Nickname JOIN #Chan"));
server.Parse(new(":Other JOIN #Chan")); server.Parse(new(":Other JOIN #Chan"));
Assert.IsTrue(server.Users.ContainsKey("nickname")); Assert.IsTrue(server.Users.ContainsKey("nickname"));
Assert.IsFalse(server.Users.ContainsKey("Nickname")); Assert.IsFalse(server.Users.ContainsKey("Nickname"));
Assert.IsTrue(server.Users.ContainsKey("other")); Assert.IsTrue(server.Users.ContainsKey("other"));
Assert.IsFalse(server.Users.ContainsKey("Other")); Assert.IsFalse(server.Users.ContainsKey("Other"));
Assert.IsTrue(server.Channels.ContainsKey("#chan")); Assert.IsTrue(server.Channels.ContainsKey("#chan"));
Assert.IsFalse(server.Channels.ContainsKey("#Chan")); Assert.IsFalse(server.Channels.ContainsKey("#Chan"));
var channel = server.Channels["#chan"]; var channel = server.Channels["#chan"];
Assert.AreEqual("#Chan", channel.Name); Assert.AreEqual("#Chan", channel.Name);
} }
[TestMethod] [TestMethod]
public void CommandNick() public void CommandNick()
{ {
var server = new Server("test"); var server = new Server("test");
server.Parse(new("001 nickname")); server.Parse(new("001 nickname"));
server.Parse(new(":nickname JOIN #chan")); server.Parse(new(":nickname JOIN #chan"));
var user = server.Users["nickname"]; var user = server.Users["nickname"];
server.Parse(new(":nickname NICK NewNickname")); server.Parse(new(":nickname NICK NewNickname"));
Assert.AreEqual(1, server.Users.Count); Assert.AreEqual(1, server.Users.Count);
Assert.IsTrue(server.Users.ContainsKey("newnickname")); Assert.IsTrue(server.Users.ContainsKey("newnickname"));
Assert.AreEqual("NewNickname", user.NickName); Assert.AreEqual("NewNickname", user.NickName);
Assert.AreEqual("newnickname", user.NickNameLower); Assert.AreEqual("newnickname", user.NickNameLower);
Assert.AreEqual("NewNickname", server.NickName); Assert.AreEqual("NewNickname", server.NickName);
Assert.AreEqual("newnickname", server.NickNameLower); Assert.AreEqual("newnickname", server.NickNameLower);
}
} }
} }

323
IRCSharp.Tests/State/Channel.cs
View File

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

215
IRCSharp.Tests/State/Emit.cs
View File

@ -1,117 +1,112 @@
using System.Collections.Generic; namespace IRCSharp.Tests.State;
using IRCStates;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Emit
{ {
[TestClass] private Server _server;
public class Emit
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
_server.Parse(new("001 nickname"));
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void EmitJoin()
{
var emit = _server.Parse(new(":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.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var emit = _server.Parse(new(":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.Parse(new(":other JOIN #chan"));
emit = _server.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var emit = _server.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var user = _server.Users["nickname"];
var channel = _server.Channels["#chan"];
_server.Parse(new(":other JOIN #chan"));
var userOther = _server.Users["other"];
var emit = _server.Parse(new(":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.Parse(new("MODE nickname x+i-i+wi-wi"));
Assert.IsNotNull(emit);
Assert.AreEqual("MODE", emit.Command);
Assert.IsTrue(emit.SelfTarget);
CollectionAssert.AreEqual(new List<string>
{ {
_server = new("test"); "+x",
_server.Parse(new("001 nickname")); "+i",
} "-i",
"+w",
[TestMethod] "+i",
public void EmitJoin() "-w",
{ "-i"
var emit = _server.Parse(new(":nickname JOIN #chan")); }, emit.Tokens);
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.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var emit = _server.Parse(new(":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.Parse(new(":other JOIN #chan"));
emit = _server.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var emit = _server.Parse(new(":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.Parse(new(":nickname JOIN #chan"));
var user = _server.Users["nickname"];
var channel = _server.Channels["#chan"];
_server.Parse(new(":other JOIN #chan"));
var userOther = _server.Users["other"];
var emit = _server.Parse(new(":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.Parse(new("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);
}
} }
} }

342
IRCSharp.Tests/State/ISupport.cs
View File

@ -1,210 +1,204 @@
using System.Collections.Generic; // ReSharper disable InconsistentNaming
using IRCStates; namespace IRCSharp.Tests.State;
using Microsoft.VisualStudio.TestTools.UnitTesting;
// ReSharper disable InconsistentNaming [TestClass]
public class ISupport
namespace IRCSharp.Tests.State
{ {
[TestClass] private Server _server;
public class ISupport
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
_server.Parse(new("001 nickname"));
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void 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>
{ {
_server = new("test"); "i",
_server.Parse(new("001 nickname")); "m",
} "n",
"p",
"s",
"t"
}, _server.ISupport.ChanModes.SettingDModes);
[TestMethod] _server.Parse(new("005 * CHANMODES=a,b,c,d *"));
public void ChanModes()
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);
}
[TestMethod]
public void Prefix()
{
CollectionAssert.AreEqual(new List<string> {"o", "v"}, _server.ISupport.Prefix.Modes);
CollectionAssert.AreEqual(new List<string> {"@", "+"}, _server.ISupport.Prefix.Prefixes);
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("&"));
_server.Parse(new("005 * PREFIX=(qaohv)~&@%+ *"));
CollectionAssert.AreEqual(new List<string>
{ {
CollectionAssert.AreEqual(new List<string> {"b"}, _server.ISupport.ChanModes.ListModes); "q",
CollectionAssert.AreEqual(new List<string> {"k"}, _server.ISupport.ChanModes.SettingBModes); "a",
CollectionAssert.AreEqual(new List<string> {"l"}, _server.ISupport.ChanModes.SettingCModes); "o",
CollectionAssert.AreEqual(new List<string> "h",
{ "v"
"i", }, _server.ISupport.Prefix.Modes);
"m", CollectionAssert.AreEqual(new List<string>
"n",
"p",
"s",
"t"
}, _server.ISupport.ChanModes.SettingDModes);
_server.Parse(new("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);
}
[TestMethod]
public void Prefix()
{ {
CollectionAssert.AreEqual(new List<string> {"o", "v"}, _server.ISupport.Prefix.Modes); "~",
CollectionAssert.AreEqual(new List<string> {"@", "+"}, _server.ISupport.Prefix.Prefixes); "&",
"@",
"%",
"+"
}, _server.ISupport.Prefix.Prefixes);
Assert.AreEqual("&", _server.ISupport.Prefix.FromMode("a"));
Assert.AreEqual("a", _server.ISupport.Prefix.FromPrefix("&"));
}
Assert.AreEqual("@", _server.ISupport.Prefix.FromMode("o")); [TestMethod]
Assert.IsNull(_server.ISupport.Prefix.FromMode("a")); public void ChanTypes()
Assert.AreEqual("o", _server.ISupport.Prefix.FromPrefix("@")); {
Assert.IsNull(_server.ISupport.Prefix.FromPrefix("&")); CollectionAssert.AreEqual(new List<string> {"#"}, _server.ISupport.ChanTypes);
_server.Parse(new("005 * CHANTYPES=#& *"));
CollectionAssert.AreEqual(new List<string> {"#", "&"}, _server.ISupport.ChanTypes);
}
_server.Parse(new("005 * PREFIX=(qaohv)~&@%+ *")); [TestMethod]
CollectionAssert.AreEqual(new List<string> public void Modes()
{ {
"q", Assert.AreEqual(3, _server.ISupport.Modes);
"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("&"));
}
[TestMethod] _server.Parse(new("005 * MODES *"));
public void ChanTypes() Assert.AreEqual(-1, _server.ISupport.Modes);
{
CollectionAssert.AreEqual(new List<string> {"#"}, _server.ISupport.ChanTypes);
_server.Parse(new("005 * CHANTYPES=#& *"));
CollectionAssert.AreEqual(new List<string> {"#", "&"}, _server.ISupport.ChanTypes);
}
[TestMethod] _server.Parse(new("005 * MODES=5 *"));
public void Modes() Assert.AreEqual(5, _server.ISupport.Modes);
{ }
Assert.AreEqual(3, _server.ISupport.Modes);
_server.Parse(new("005 * MODES *")); [TestMethod]
Assert.AreEqual(-1, _server.ISupport.Modes); public void Rfc1459()
{
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
_server.Parse(new("005 * CASEMAPPING=rfc1459 *"));
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
var lower = _server.CaseFold(@"ÀTEST[]~\");
Assert.AreEqual("Àtest{}^|", lower);
}
_server.Parse(new("005 * MODES=5 *")); [TestMethod]
Assert.AreEqual(5, _server.ISupport.Modes); public void Ascii()
} {
_server.Parse(new("005 * CASEMAPPING=ascii *"));
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Ascii, _server.ISupport.CaseMapping);
var lower = _server.CaseFold(@"ÀTEST[]~\");
Assert.AreEqual(@"Àtest[]~\", lower);
}
[TestMethod] [TestMethod]
public void Rfc1459() public void FallbackToRfc1459()
{ {
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping); _server.Parse(new("005 * CASEMAPPING=nonexistent *"));
_server.Parse(new("005 * CASEMAPPING=rfc1459 *")); Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping);
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping); var lower = _server.CaseFold(@"ÀTEST[]~\");
var lower = _server.CaseFold(@"ÀTEST[]~\"); Assert.AreEqual("Àtest{}^|", lower);
Assert.AreEqual("Àtest{}^|", lower); }
}
[TestMethod] [TestMethod]
public void Ascii() public void Network()
{ {
_server.Parse(new("005 * CASEMAPPING=ascii *")); Assert.IsNull(_server.ISupport.Network);
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Ascii, _server.ISupport.CaseMapping); _server.Parse(new("005 * NETWORK=testnet *"));
var lower = _server.CaseFold(@"ÀTEST[]~\"); Assert.AreEqual("testnet", _server.ISupport.Network);
Assert.AreEqual(@"Àtest[]~\", lower); }
}
[TestMethod] [TestMethod]
public void FallbackToRfc1459() public void StatusMsg()
{ {
_server.Parse(new("005 * CASEMAPPING=nonexistent *")); CollectionAssert.AreEqual(new List<string>(), _server.ISupport.StatusMsg);
Assert.AreEqual(IRCStates.Casemap.CaseMapping.Rfc1459, _server.ISupport.CaseMapping); _server.Parse(new("005 * STATUSMSG=&@ *"));
var lower = _server.CaseFold(@"ÀTEST[]~\"); CollectionAssert.AreEqual(new List<string> {"&", "@"}, _server.ISupport.StatusMsg);
Assert.AreEqual("Àtest{}^|", lower); }
}
[TestMethod] [TestMethod]
public void Network() public void CallerId()
{ {
Assert.IsNull(_server.ISupport.Network); Assert.IsNull(_server.ISupport.CallerId);
_server.Parse(new("005 * NETWORK=testnet *"));
Assert.AreEqual("testnet", _server.ISupport.Network);
}
[TestMethod] _server.Parse(new("005 * CALLERID=U *"));
public void StatusMsg() Assert.AreEqual("U", _server.ISupport.CallerId);
{
CollectionAssert.AreEqual(new List<string>(), _server.ISupport.StatusMsg);
_server.Parse(new("005 * STATUSMSG=&@ *"));
CollectionAssert.AreEqual(new List<string> {"&", "@"}, _server.ISupport.StatusMsg);
}
[TestMethod] _server.Parse(new("005 * CALLERID *"));
public void CallerId() Assert.AreEqual("g", _server.ISupport.CallerId);
{ }
Assert.IsNull(_server.ISupport.CallerId);
_server.Parse(new("005 * CALLERID=U *")); [TestMethod]
Assert.AreEqual("U", _server.ISupport.CallerId); public void Excepts()
{
Assert.IsNull(_server.ISupport.Excepts);
_server.Parse(new("005 * CALLERID *")); _server.Parse(new("005 * EXCEPTS=U *"));
Assert.AreEqual("g", _server.ISupport.CallerId); Assert.AreEqual("U", _server.ISupport.Excepts);
}
[TestMethod] _server.Parse(new("005 * EXCEPTS *"));
public void Excepts() Assert.AreEqual("e", _server.ISupport.Excepts);
{ }
Assert.IsNull(_server.ISupport.Excepts);
_server.Parse(new("005 * EXCEPTS=U *")); [TestMethod]
Assert.AreEqual("U", _server.ISupport.Excepts); public void Invex()
{
Assert.IsNull(_server.ISupport.Invex);
_server.Parse(new("005 * EXCEPTS *")); _server.Parse(new("005 * INVEX=U *"));
Assert.AreEqual("e", _server.ISupport.Excepts); Assert.AreEqual("U", _server.ISupport.Invex);
}
[TestMethod] _server.Parse(new("005 * INVEX *"));
public void Invex() Assert.AreEqual("I", _server.ISupport.Invex);
{ }
Assert.IsNull(_server.ISupport.Invex);
_server.Parse(new("005 * INVEX=U *")); [TestMethod]
Assert.AreEqual("U", _server.ISupport.Invex); public void Whox()
{
Assert.IsFalse(_server.ISupport.Whox);
_server.Parse(new("005 * INVEX *")); _server.Parse(new("005 * WHOX *"));
Assert.AreEqual("I", _server.ISupport.Invex); Assert.IsTrue(_server.ISupport.Whox);
} }
[TestMethod] [TestMethod]
public void Whox() public void Monitor()
{ {
Assert.IsFalse(_server.ISupport.Whox); Assert.IsNull(_server.ISupport.Monitor);
_server.Parse(new("005 * WHOX *")); _server.Parse(new("005 * MONITOR=123 *"));
Assert.IsTrue(_server.ISupport.Whox); Assert.AreEqual(123, _server.ISupport.Monitor);
}
[TestMethod] _server.Parse(new("005 * MONITOR *"));
public void Monitor() Assert.AreEqual(-1, _server.ISupport.Monitor);
{ }
Assert.IsNull(_server.ISupport.Monitor);
_server.Parse(new("005 * MONITOR=123 *")); [TestMethod]
Assert.AreEqual(123, _server.ISupport.Monitor); public void Watch()
{
Assert.IsNull(_server.ISupport.Watch);
_server.Parse(new("005 * MONITOR *")); _server.Parse(new("005 * WATCH=123 *"));
Assert.AreEqual(-1, _server.ISupport.Monitor); Assert.AreEqual(123, _server.ISupport.Watch);
}
[TestMethod] _server.Parse(new("005 * WATCH *"));
public void Watch() Assert.AreEqual(-1, _server.ISupport.Watch);
{
Assert.IsNull(_server.ISupport.Watch);
_server.Parse(new("005 * WATCH=123 *"));
Assert.AreEqual(123, _server.ISupport.Watch);
_server.Parse(new("005 * WATCH *"));
Assert.AreEqual(-1, _server.ISupport.Watch);
}
} }
} }

287
IRCSharp.Tests/State/Mode.cs
View File

@ -1,179 +1,174 @@
using System.Collections.Generic; namespace IRCSharp.Tests.State;
using IRCStates;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Mode
{ {
[TestClass] private Server _server;
public class Mode
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
_server.Parse(new("001 nickname"));
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void UModeAdd()
{ {
_server = new("test"); _server.Parse(new("MODE nickname +i"));
_server.Parse(new("001 nickname")); CollectionAssert.AreEqual(new List<string> {"i"}, _server.Modes);
} }
[TestMethod] [TestMethod]
public void UModeAdd() public void UModeRemove()
{ {
_server.Parse(new("MODE nickname +i")); _server.Parse(new("MODE nickname +i"));
CollectionAssert.AreEqual(new List<string> {"i"}, _server.Modes); _server.Parse(new("MODE nickname -i"));
} CollectionAssert.AreEqual(new List<string>(), _server.Modes);
}
[TestMethod] [TestMethod]
public void UModeRemove() public void PrefixAdd()
{ {
_server.Parse(new("MODE nickname +i")); _server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE nickname -i")); _server.Parse(new("MODE #chan +ov nickname nickname"));
CollectionAssert.AreEqual(new List<string>(), _server.Modes);
}
[TestMethod] var user = _server.Users["nickname"];
public void PrefixAdd() var channel = _server.Channels["#chan"];
{ var channelUser = channel.Users[user.NickNameLower];
_server.Parse(new(":nickname JOIN #chan")); CollectionAssert.AreEqual(new List<string> {"o", "v"}, channelUser.Modes);
_server.Parse(new("MODE #chan +ov nickname nickname")); }
var user = _server.Users["nickname"]; [TestMethod]
var channel = _server.Channels["#chan"]; public void PrefixRemove()
var channelUser = channel.Users[user.NickNameLower]; {
CollectionAssert.AreEqual(new List<string> {"o", "v"}, channelUser.Modes); _server.Parse(new(":nickname JOIN #chan"));
} _server.Parse(new("MODE #chan +ov nickname nickname"));
_server.Parse(new("MODE #chan -ov nickname nickname"));
[TestMethod] var user = _server.Users["nickname"];
public void PrefixRemove() var channel = _server.Channels["#chan"];
{ var channelUser = channel.Users[user.NickNameLower];
_server.Parse(new(":nickname JOIN #chan")); CollectionAssert.AreEqual(new List<string>(), channelUser.Modes);
_server.Parse(new("MODE #chan +ov nickname nickname")); }
_server.Parse(new("MODE #chan -ov nickname nickname"));
var user = _server.Users["nickname"]; [TestMethod]
var channel = _server.Channels["#chan"]; public void ChannelListAdd()
var channelUser = channel.Users[user.NickNameLower]; {
CollectionAssert.AreEqual(new List<string>(), channelUser.Modes); _server.Parse(new(":nickname JOIN #chan"));
} _server.Parse(new("MODE #chan +b asd!*@*"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelListAdd() CollectionAssert.AreEqual(new List<string> {"asd!*@*"}, channel.ListModes["b"]);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +b asd!*@*"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new List<string> {"asd!*@*"}, channel.ListModes["b"]); public void ChannelListRemove()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +b asd!*@*"));
_server.Parse(new("MODE #chan -b asd!*@*"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelListRemove() CollectionAssert.AreEqual(new Dictionary<string, List<string>>(), channel.ListModes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +b asd!*@*"));
_server.Parse(new("MODE #chan -b asd!*@*"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, List<string>>(), channel.ListModes); public void ChannelTypeBAdd()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +k password"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeBAdd() CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "password"}}, channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +k password"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "password"}}, channel.Modes); public void ChannelTypeBRemove()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +k password"));
_server.Parse(new("MODE #chan -k *"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeBRemove() CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +k password"));
_server.Parse(new("MODE #chan -k *"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes); public void ChannelTypeCAdd()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +l 100"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeCAdd() CollectionAssert.AreEqual(new Dictionary<string, string> {{"l", "100"}}, channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +l 100"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string> {{"l", "100"}}, channel.Modes); public void ChannelTypeCRemove()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +l 100"));
_server.Parse(new("MODE #chan -l"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeCRemove() CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +l 100"));
_server.Parse(new("MODE #chan -l"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes); public void ChannelTypeDAdd()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +i"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeDAdd() CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}}, channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +i"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}}, channel.Modes); public void ChannelTypeDRemove()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +i"));
_server.Parse(new("MODE #chan -i"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelTypeDRemove() CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("MODE #chan +i"));
_server.Parse(new("MODE #chan -i"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string>(), channel.Modes); public void ChannelNumeric()
} {
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("324 * #chan +bkli *!*@* pass 10"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelNumeric() CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "pass"}, {"l", "10"}, {"i", null}},
{ channel.Modes);
_server.Parse(new(":nickname JOIN #chan")); CollectionAssert.AreEqual(new List<string> {"*!*@*"}, channel.ListModes["b"]);
_server.Parse(new("324 * #chan +bkli *!*@* pass 10")); }
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string> {{"k", "pass"}, {"l", "10"}, {"i", null}}, public void ChannelNumericWithoutPlus()
channel.Modes); {
CollectionAssert.AreEqual(new List<string> {"*!*@*"}, channel.ListModes["b"]); _server.Parse(new(":nickname JOIN #chan"));
} _server.Parse(new("324 * #chan il 10"));
[TestMethod] var channel = _server.Channels["#chan"];
public void ChannelNumericWithoutPlus() CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}, {"l", "10"}}, channel.Modes);
{ }
_server.Parse(new(":nickname JOIN #chan"));
_server.Parse(new("324 * #chan il 10"));
var channel = _server.Channels["#chan"]; [TestMethod]
CollectionAssert.AreEqual(new Dictionary<string, string> {{"i", null}, {"l", "10"}}, channel.Modes); public void UserNumeric()
} {
_server.Parse(new("221 * +iw"));
CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes);
}
[TestMethod] [TestMethod]
public void UserNumeric() public void UserNumericWithoutPlus()
{ {
_server.Parse(new("221 * +iw")); _server.Parse(new("221 * iw"));
CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes); CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes);
}
[TestMethod]
public void UserNumericWithoutPlus()
{
_server.Parse(new("221 * iw"));
CollectionAssert.AreEqual(new List<string> {"i", "w"}, _server.Modes);
}
} }
} }

29
IRCSharp.Tests/State/Motd.cs
View File

@ -1,23 +1,18 @@
using System.Collections.Generic; namespace IRCSharp.Tests.State;
using IRCStates;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Motd
{ {
[TestClass] [TestMethod]
public class Motd public void MessageOfTheDay()
{ {
[TestMethod] var server = new Server("test");
public void MessageOfTheDay() server.Parse(new("001 nickname"));
{ server.Parse(new("375 * :start of motd"));
var server = new Server("test"); server.Parse(new("372 * :first line of motd"));
server.Parse(new("001 nickname")); server.Parse(new("372 * :second line of motd"));
server.Parse(new("375 * :start of motd"));
server.Parse(new("372 * :first line of motd"));
server.Parse(new("372 * :second line of motd"));
CollectionAssert.AreEqual(new List<string> {"start of motd", "first line of motd", "second line of motd"}, CollectionAssert.AreEqual(new List<string> {"start of motd", "first line of motd", "second line of motd"},
server.Motd); server.Motd);
}
} }
} }

56
IRCSharp.Tests/State/Sasl.cs
View File

@ -1,38 +1,34 @@
using IRCStates; namespace IRCSharp.Tests.State;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Sasl
{ {
[TestClass] private Server _server;
public class Sasl
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
_server.Parse(new("900 * nick!user@host account"));
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void LoggedIn()
{ {
_server = new("test"); Assert.AreEqual("nick", _server.NickName);
_server.Parse(new("900 * nick!user@host account")); Assert.AreEqual("user", _server.UserName);
} Assert.AreEqual("host", _server.HostName);
Assert.AreEqual("account", _server.Account);
}
[TestMethod] [TestMethod]
public void LoggedIn() public void LoggedOut()
{ {
Assert.AreEqual("nick", _server.NickName); _server.Parse(new("901 * nick1!user1@host1"));
Assert.AreEqual("user", _server.UserName);
Assert.AreEqual("host", _server.HostName);
Assert.AreEqual("account", _server.Account);
}
[TestMethod] Assert.AreEqual("nick1", _server.NickName);
public void LoggedOut() Assert.AreEqual("user1", _server.UserName);
{ Assert.AreEqual("host1", _server.HostName);
_server.Parse(new("901 * nick1!user1@host1")); Assert.IsTrue(string.IsNullOrEmpty(_server.Account));
Assert.AreEqual("nick1", _server.NickName);
Assert.AreEqual("user1", _server.UserName);
Assert.AreEqual("host1", _server.HostName);
Assert.IsTrue(string.IsNullOrEmpty(_server.Account));
}
} }
} }

500
IRCSharp.Tests/State/User.cs
View File

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

92
IRCSharp.Tests/State/Who.cs
View File

@ -1,61 +1,57 @@
using IRCStates; namespace IRCSharp.Tests.State;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.State [TestClass]
public class Who
{ {
[TestClass] private Server _server;
public class Who
[TestInitialize]
public void TestInitialize()
{ {
private Server _server; _server = new("test");
_server.Parse(new("001 nickname"));
_server.Parse(new(":nickname JOIN #chan"));
}
[TestInitialize] [TestMethod]
public void TestInitialize() public void WhoResponse()
{ {
_server = new("test"); _server.Parse(new("352 * #chan user host server nickname * :0 real"));
_server.Parse(new("001 nickname")); var user = _server.Users["nickname"];
_server.Parse(new(":nickname JOIN #chan"));
}
[TestMethod] Assert.AreEqual("user", user.UserName);
public void WhoResponse() Assert.AreEqual("host", _server.HostName);
{ Assert.AreEqual("real", user.RealName);
_server.Parse(new("352 * #chan user host server nickname * :0 real"));
var user = _server.Users["nickname"];
Assert.AreEqual("user", user.UserName); Assert.AreEqual(user.UserName, _server.UserName);
Assert.AreEqual("host", _server.HostName); Assert.AreEqual(user.HostName, _server.HostName);
Assert.AreEqual("real", user.RealName); Assert.AreEqual(user.RealName, _server.RealName);
}
Assert.AreEqual(user.UserName, _server.UserName); [TestMethod]
Assert.AreEqual(user.HostName, _server.HostName); public void Whox()
Assert.AreEqual(user.RealName, _server.RealName); {
} _server.Parse(new($"354 * {Server.WhoType} user realip host nickname account :real"));
var user = _server.Users["nickname"];
[TestMethod] Assert.AreEqual("user", user.UserName);
public void Whox() Assert.AreEqual("host", user.HostName);
{ Assert.AreEqual("real", user.RealName);
_server.Parse(new($"354 * {Server.WhoType} user realip host nickname account :real")); Assert.AreEqual("account", user.Account);
var user = _server.Users["nickname"];
Assert.AreEqual("user", user.UserName); Assert.AreEqual(user.UserName, _server.UserName);
Assert.AreEqual("host", user.HostName); Assert.AreEqual(user.HostName, _server.HostName);
Assert.AreEqual("real", user.RealName); Assert.AreEqual(user.RealName, _server.RealName);
Assert.AreEqual("account", user.Account); Assert.AreEqual(user.Account, _server.Account);
}
Assert.AreEqual(user.UserName, _server.UserName); [TestMethod]
Assert.AreEqual(user.HostName, _server.HostName); public void WhoxNoAccount()
Assert.AreEqual(user.RealName, _server.RealName); {
Assert.AreEqual(user.Account, _server.Account); _server.Parse(new($"354 * {Server.WhoType} user realip host nickname 0 :real"));
} var user = _server.Users["nickname"];
[TestMethod] Assert.IsNull(user.Account);
public void WhoxNoAccount() Assert.AreEqual(user.Account, _server.Account);
{
_server.Parse(new($"354 * {Server.WhoType} user realip host nickname 0 :real"));
var user = _server.Users["nickname"];
Assert.IsNull(user.Account);
Assert.AreEqual(user.Account, _server.Account);
}
} }
} }

36
IRCSharp.Tests/Tokenization/Data/JoinModel.cs
View File

@ -1,30 +1,28 @@
using System.Collections.Generic; using YamlDotNet.Serialization;
using YamlDotNet.Serialization;
namespace IRCSharp.Tests.Tokenization.Data namespace IRCSharp.Tests.Tokenization.Data;
public class JoinModel
{ {
public class JoinModel public List<Test> Tests { get; set; }
public class Test
{ {
public List<Test> Tests { get; set; } [YamlMember(Alias = "desc")] public string Description { get; set; }
public class Test public Atoms Atoms { get; set; }
{
[YamlMember(Alias = "desc")] public string Description { get; set; }
public Atoms Atoms { get; set; } public List<string> Matches { get; set; }
}
public List<string> Matches { get; set; } public class Atoms
} {
public Dictionary<string, string> Tags { get; set; }
public class Atoms public string Source { get; set; }
{
public Dictionary<string, string> Tags { get; set; }
public string Source { get; set; } public string Verb { get; set; }
public string Verb { get; set; } public List<string> Params { get; set; }
public List<string> Params { get; set; }
}
} }
} }

17
IRCSharp.Tests/Tokenization/Data/SplitModel.cs
View File

@ -1,15 +1,12 @@
using System.Collections.Generic; namespace IRCSharp.Tests.Tokenization.Data;
namespace IRCSharp.Tests.Tokenization.Data public class SplitModel
{ {
public class SplitModel public List<Test> Tests { get; set; }
{
public List<Test> Tests { get; set; }
public class Test public class Test
{ {
public string Input { get; set; } public string Input { get; set; }
public JoinModel.Atoms Atoms { get; set; } public JoinModel.Atoms Atoms { get; set; }
}
} }
} }

155
IRCSharp.Tests/Tokenization/Format.cs
View File

@ -1,105 +1,100 @@
using System; namespace IRCSharp.Tests.Tokenization;
using IRCTokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.Tokenization [TestClass]
public class Format
{ {
[TestClass] [TestMethod]
public class Format public void Tags()
{ {
[TestMethod] var line = new Line("PRIVMSG", "#channel", "hello")
public void Tags()
{ {
var line = new Line("PRIVMSG", "#channel", "hello") Tags = new() {{"id", "\\" + " " + ";" + "\r\n"}}
{ }.Format();
Tags = new() {{"id", "\\" + " " + ";" + "\r\n"}}
}.Format();
Assert.AreEqual("@id=\\\\\\s\\:\\r\\n PRIVMSG #channel hello", line); Assert.AreEqual(@"@id=\\\s\:\r\n PRIVMSG #channel hello", line);
} }
[TestMethod] [TestMethod]
public void MissingTag() public void MissingTag()
{ {
var line = new Line("PRIVMSG", "#channel", "hello").Format(); var line = new Line("PRIVMSG", "#channel", "hello").Format();
Assert.AreEqual("PRIVMSG #channel hello", line); Assert.AreEqual("PRIVMSG #channel hello", line);
} }
[TestMethod] [TestMethod]
public void NullTag() public void NullTag()
{ {
var line = new Line("PRIVMSG", "#channel", "hello") {Tags = new() {{"a", null}}} var line = new Line("PRIVMSG", "#channel", "hello") {Tags = new() {{"a", null}}}
.Format(); .Format();
Assert.AreEqual("@a PRIVMSG #channel hello", line); Assert.AreEqual("@a PRIVMSG #channel hello", line);
} }
[TestMethod] [TestMethod]
public void EmptyTag() public void EmptyTag()
{ {
var line = new Line("PRIVMSG", "#channel", "hello") {Tags = new() {{"a", ""}}} var line = new Line("PRIVMSG", "#channel", "hello") {Tags = new() {{"a", ""}}}
.Format(); .Format();
Assert.AreEqual("@a PRIVMSG #channel hello", line); Assert.AreEqual("@a PRIVMSG #channel hello", line);
} }
[TestMethod] [TestMethod]
public void Source() public void Source()
{ {
var line = new Line("PRIVMSG", "#channel", "hello") {Source = "nick!user@host"}.Format(); var line = new Line("PRIVMSG", "#channel", "hello") {Source = "nick!user@host"}.Format();
Assert.AreEqual(":nick!user@host PRIVMSG #channel hello", line); Assert.AreEqual(":nick!user@host PRIVMSG #channel hello", line);
} }
[TestMethod] [TestMethod]
public void CommandLowercase() public void CommandLowercase()
{ {
var line = new Line {Command = "privmsg"}.Format(); var line = new Line {Command = "privmsg"}.Format();
Assert.AreEqual("privmsg", line); Assert.AreEqual("privmsg", line);
} }
[TestMethod] [TestMethod]
public void CommandUppercase() public void CommandUppercase()
{ {
var line = new Line {Command = "PRIVMSG"}.Format(); var line = new Line {Command = "PRIVMSG"}.Format();
Assert.AreEqual("PRIVMSG", line); Assert.AreEqual("PRIVMSG", line);
} }
[TestMethod] [TestMethod]
public void TrailingSpace() public void TrailingSpace()
{ {
var line = new Line("PRIVMSG", "#channel", "hello world").Format(); var line = new Line("PRIVMSG", "#channel", "hello world").Format();
Assert.AreEqual("PRIVMSG #channel :hello world", line); Assert.AreEqual("PRIVMSG #channel :hello world", line);
} }
[TestMethod] [TestMethod]
public void TrailingNoSpace() public void TrailingNoSpace()
{ {
var line = new Line("PRIVMSG", "#channel", "helloworld").Format(); var line = new Line("PRIVMSG", "#channel", "helloworld").Format();
Assert.AreEqual("PRIVMSG #channel helloworld", line); Assert.AreEqual("PRIVMSG #channel helloworld", line);
} }
[TestMethod] [TestMethod]
public void TrailingDoubleColon() public void TrailingDoubleColon()
{ {
var line = new Line("PRIVMSG", "#channel", ":helloworld").Format(); var line = new Line("PRIVMSG", "#channel", ":helloworld").Format();
Assert.AreEqual("PRIVMSG #channel ::helloworld", line); Assert.AreEqual("PRIVMSG #channel ::helloworld", line);
} }
[TestMethod] [TestMethod]
public void InvalidNonLastSpace() public void InvalidNonLastSpace()
{ {
Assert.ThrowsException<ArgumentException>(() => { new Line("USER", "user", "0 *", "real name").Format(); }); Assert.ThrowsException<ArgumentException>(() => { new Line("USER", "user", "0 *", "real name").Format(); });
} }
[TestMethod] [TestMethod]
public void InvalidNonLastColon() public void InvalidNonLastColon()
{ {
Assert.ThrowsException<ArgumentException>(() => { new Line("PRIVMSG", ":#channel", "hello").Format(); }); Assert.ThrowsException<ArgumentException>(() => { new Line("PRIVMSG", ":#channel", "hello").Format(); });
}
} }
} }

106
IRCSharp.Tests/Tokenization/Hostmask.cs
View File

@ -1,65 +1,61 @@
using IRCTokens; namespace IRCSharp.Tests.Tokenization;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.Tokenization [TestClass]
public class Hostmask
{ {
[TestClass] [TestMethod]
public class Hostmask public void FullHostmask()
{ {
[TestMethod] var hostmask = new IRCTokens.Hostmask("nick!user@host");
public void FullHostmask() Assert.AreEqual("nick", hostmask.NickName);
{ Assert.AreEqual("user", hostmask.UserName);
var hostmask = new IRCTokens.Hostmask("nick!user@host"); Assert.AreEqual("host", hostmask.HostName);
Assert.AreEqual("nick", hostmask.NickName); }
Assert.AreEqual("user", hostmask.UserName);
Assert.AreEqual("host", hostmask.HostName);
}
[TestMethod] [TestMethod]
public void NoHostName() public void NoHostName()
{ {
var hostmask = new IRCTokens.Hostmask("nick!user"); var hostmask = new IRCTokens.Hostmask("nick!user");
Assert.AreEqual("nick", hostmask.NickName); Assert.AreEqual("nick", hostmask.NickName);
Assert.AreEqual("user", hostmask.UserName); Assert.AreEqual("user", hostmask.UserName);
Assert.IsNull(hostmask.HostName); Assert.IsNull(hostmask.HostName);
} }
[TestMethod] [TestMethod]
public void NoUserName() public void NoUserName()
{ {
var hostmask = new IRCTokens.Hostmask("nick@host"); var hostmask = new IRCTokens.Hostmask("nick@host");
Assert.AreEqual("nick", hostmask.NickName); Assert.AreEqual("nick", hostmask.NickName);
Assert.IsNull(hostmask.UserName); Assert.IsNull(hostmask.UserName);
Assert.AreEqual("host", hostmask.HostName); Assert.AreEqual("host", hostmask.HostName);
} }
[TestMethod] [TestMethod]
public void OnlyNickName() public void OnlyNickName()
{ {
var hostmask = new IRCTokens.Hostmask("nick"); var hostmask = new IRCTokens.Hostmask("nick");
Assert.AreEqual("nick", hostmask.NickName); Assert.AreEqual("nick", hostmask.NickName);
Assert.IsNull(hostmask.UserName); Assert.IsNull(hostmask.UserName);
Assert.IsNull(hostmask.HostName); Assert.IsNull(hostmask.HostName);
} }
[TestMethod] [TestMethod]
public void HostmaskFromLine() public void HostmaskFromLine()
{ {
var line = new Line(":nick!user@host PRIVMSG #channel hello"); var line = new Line(":nick!user@host PRIVMSG #channel hello");
var hostmask = new IRCTokens.Hostmask("nick!user@host"); var hostmask = new IRCTokens.Hostmask("nick!user@host");
Assert.AreEqual(hostmask.ToString(), line.Hostmask.ToString()); Assert.AreEqual(hostmask.ToString(), line.Hostmask.ToString());
Assert.AreEqual("nick", line.Hostmask.NickName); Assert.AreEqual("nick", line.Hostmask.NickName);
Assert.AreEqual("user", line.Hostmask.UserName); Assert.AreEqual("user", line.Hostmask.UserName);
Assert.AreEqual("host", line.Hostmask.HostName); Assert.AreEqual("host", line.Hostmask.HostName);
} }
[TestMethod] [TestMethod]
public void EmptyHostmaskFromLine() public void EmptyHostmaskFromLine()
{ {
var line = new Line("PRIVMSG #channel hello"); var line = new Line("PRIVMSG #channel hello");
Assert.IsNull(line.Hostmask.HostName); Assert.IsNull(line.Hostmask.HostName);
Assert.IsNull(line.Hostmask.UserName); Assert.IsNull(line.Hostmask.UserName);
Assert.IsNull(line.Hostmask.NickName); Assert.IsNull(line.Hostmask.NickName);
}
} }
} }

76
IRCSharp.Tests/Tokenization/Parser.cs
View File

@ -1,56 +1,52 @@
using System.Collections.Generic; using System.Globalization;
using System.Globalization;
using System.IO; using System.IO;
using IRCSharp.Tests.Tokenization.Data; using IRCSharp.Tests.Tokenization.Data;
using IRCTokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using YamlDotNet.Serialization; using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions; using YamlDotNet.Serialization.NamingConventions;
namespace IRCSharp.Tests.Tokenization namespace IRCSharp.Tests.Tokenization;
[TestClass]
public class Parser
{ {
[TestClass] private static T LoadYaml<T>(string path)
public class Parser
{ {
private static T LoadYaml<T>(string path) var deserializer = new DeserializerBuilder()
{ .WithNamingConvention(CamelCaseNamingConvention.Instance)
var deserializer = new DeserializerBuilder() .Build();
.WithNamingConvention(CamelCaseNamingConvention.Instance)
.Build();
return deserializer.Deserialize<T>(File.ReadAllText(path)); return deserializer.Deserialize<T>(File.ReadAllText(path));
}
[TestMethod]
public void Split()
{
foreach (var test in LoadYaml<SplitModel>("Tokenization/Data/msg-split.yaml").Tests)
{
var tokens = new Line(test.Input);
var atoms = test.Atoms;
Assert.AreEqual(atoms.Verb.ToUpper(CultureInfo.InvariantCulture), tokens.Command,
$"command failed on: '{test.Input}'");
Assert.AreEqual(atoms.Source, tokens.Source, $"source failed on: '{test.Input}'");
CollectionAssert.AreEqual(atoms.Tags, tokens.Tags, $"tags failed on: '{test.Input}'");
CollectionAssert.AreEqual(atoms.Params ?? [], tokens.Params,
$"params failed on: '{test.Input}'");
} }
}
[TestMethod] [TestMethod]
public void Split() public void Join()
{
foreach (var test in LoadYaml<JoinModel>("Tokenization/Data/msg-join.yaml").Tests)
{ {
foreach (var test in LoadYaml<SplitModel>("Tokenization/Data/msg-split.yaml").Tests) var atoms = test.Atoms;
var line = new Line
{ {
var tokens = new Line(test.Input); Command = atoms.Verb, Params = atoms.Params, Source = atoms.Source, Tags = atoms.Tags
var atoms = test.Atoms; }.Format();
Assert.AreEqual(atoms.Verb.ToUpper(CultureInfo.InvariantCulture), tokens.Command, Assert.IsTrue(test.Matches.Contains(line), test.Description);
$"command failed on: '{test.Input}'");
Assert.AreEqual(atoms.Source, tokens.Source, $"source failed on: '{test.Input}'");
CollectionAssert.AreEqual(atoms.Tags, tokens.Tags, $"tags failed on: '{test.Input}'");
CollectionAssert.AreEqual(atoms.Params ?? new List<string>(), tokens.Params,
$"params failed on: '{test.Input}'");
}
}
[TestMethod]
public void Join()
{
foreach (var test in LoadYaml<JoinModel>("Tokenization/Data/msg-join.yaml").Tests)
{
var atoms = test.Atoms;
var line = new Line
{
Command = atoms.Verb, Params = atoms.Params, Source = atoms.Source, Tags = atoms.Tags
}.Format();
Assert.IsTrue(test.Matches.Contains(line), test.Description);
}
} }
} }
} }

142
IRCSharp.Tests/Tokenization/StatefulDecoder.cs
View File

@ -1,89 +1,83 @@
using System.Collections.Generic; namespace IRCSharp.Tests.Tokenization;
using System.Text;
using IRCTokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.Tokenization [TestClass]
public class StatefulDecoder
{ {
[TestClass] private IRCTokens.StatefulDecoder _decoder;
public class StatefulDecoder
[TestInitialize]
public void Initialize()
{ {
private IRCTokens.StatefulDecoder _decoder; _decoder = new();
}
[TestInitialize] [TestMethod]
public void Initialize() public void Partial()
{ {
_decoder = new(); var lines = _decoder.Push("PRIVMSG ");
} Assert.AreEqual(0, lines.Count);
[TestMethod] lines = _decoder.Push("#channel hello\r\n");
public void Partial() Assert.AreEqual(1, lines.Count);
{
var lines = _decoder.Push("PRIVMSG ");
Assert.AreEqual(0, lines.Count);
lines = _decoder.Push("#channel hello\r\n"); var line = new Line("PRIVMSG #channel hello");
Assert.AreEqual(1, lines.Count); CollectionAssert.AreEqual(new List<Line> {line}, lines);
}
var line = new Line("PRIVMSG #channel hello"); [TestMethod]
CollectionAssert.AreEqual(new List<Line> {line}, lines); public void Multiple()
} {
var lines = _decoder.Push("PRIVMSG #channel1 hello\r\nPRIVMSG #channel2 hello\r\n");
Assert.AreEqual(2, lines.Count);
[TestMethod] var line1 = new Line("PRIVMSG #channel1 hello");
public void Multiple() var line2 = new Line("PRIVMSG #channel2 hello");
{ Assert.AreEqual(line1, lines[0]);
var lines = _decoder.Push("PRIVMSG #channel1 hello\r\nPRIVMSG #channel2 hello\r\n"); Assert.AreEqual(line2, lines[1]);
Assert.AreEqual(2, lines.Count); }
var line1 = new Line("PRIVMSG #channel1 hello"); [TestMethod]
var line2 = new Line("PRIVMSG #channel2 hello"); public void EncodingIso8859()
Assert.AreEqual(line1, lines[0]); {
Assert.AreEqual(line2, lines[1]); var iso8859 = Encoding.GetEncoding("iso-8859-1");
} _decoder = new() {Encoding = iso8859};
var bytes = iso8859.GetBytes("PRIVMSG #channel :hello Ç\r\n");
var lines = _decoder.Push(bytes, bytes.Length);
var line = new Line("PRIVMSG #channel :hello Ç");
Assert.IsTrue(line.Equals(lines[0]));
}
[TestMethod] [TestMethod]
public void EncodingIso8859() public void EncodingFallback()
{ {
var iso8859 = Encoding.GetEncoding("iso-8859-1"); var latin1 = Encoding.GetEncoding("iso-8859-1");
_decoder = new() {Encoding = iso8859}; _decoder = new() {Encoding = null, Fallback = latin1};
var bytes = iso8859.GetBytes("PRIVMSG #channel :hello Ç\r\n"); var bytes = latin1.GetBytes("PRIVMSG #channel hélló\r\n");
var lines = _decoder.Push(bytes, bytes.Length); var lines = _decoder.Push(bytes, bytes.Length);
var line = new Line("PRIVMSG #channel :hello Ç"); Assert.AreEqual(1, lines.Count);
Assert.IsTrue(line.Equals(lines[0])); Assert.IsTrue(new Line("PRIVMSG #channel hélló").Equals(lines[0]));
} }
[TestMethod] [TestMethod]
public void EncodingFallback() public void Empty()
{ {
var latin1 = Encoding.GetEncoding("iso-8859-1"); var lines = _decoder.Push(string.Empty);
_decoder = new() {Encoding = null, Fallback = latin1}; Assert.AreEqual(0, lines.Count);
var bytes = latin1.GetBytes("PRIVMSG #channel hélló\r\n"); }
var lines = _decoder.Push(bytes, bytes.Length);
Assert.AreEqual(1, lines.Count);
Assert.IsTrue(new Line("PRIVMSG #channel hélló").Equals(lines[0]));
}
[TestMethod] [TestMethod]
public void Empty() public void BufferUnfinished()
{ {
var lines = _decoder.Push(string.Empty); _decoder.Push("PRIVMSG #channel hello");
Assert.AreEqual(0, lines.Count); var lines = _decoder.Push(string.Empty);
} Assert.AreEqual(0, lines.Count);
}
[TestMethod] [TestMethod]
public void BufferUnfinished() public void Clear()
{ {
_decoder.Push("PRIVMSG #channel hello"); _decoder.Push("PRIVMSG ");
var lines = _decoder.Push(string.Empty); _decoder.Clear();
Assert.AreEqual(0, lines.Count); Assert.AreEqual(string.Empty, _decoder.Pending);
}
[TestMethod]
public void Clear()
{
_decoder.Push("PRIVMSG ");
_decoder.Clear();
Assert.AreEqual(string.Empty, _decoder.Pending);
}
} }
} }

139
IRCSharp.Tests/Tokenization/StatefulEncoder.cs
View File

@ -1,85 +1,80 @@
using System.Text; namespace IRCSharp.Tests.Tokenization;
using IRCTokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.Tokenization [TestClass]
public class StatefulEncoder
{ {
[TestClass] private IRCTokens.StatefulEncoder _encoder;
public class StatefulEncoder
[TestInitialize]
public void Initialize()
{ {
private IRCTokens.StatefulEncoder _encoder; _encoder = new();
}
[TestInitialize] [TestMethod]
public void Initialize() public void Push()
{ {
_encoder = new(); var line = new Line("PRIVMSG #channel hello");
} _encoder.Push(line);
Assert.AreEqual("PRIVMSG #channel hello\r\n", _encoder.Pending());
}
[TestMethod] [TestMethod]
public void Push() public void PopPartial()
{ {
var line = new Line("PRIVMSG #channel hello"); var line = new Line("PRIVMSG #channel hello");
_encoder.Push(line); _encoder.Push(line);
Assert.AreEqual("PRIVMSG #channel hello\r\n", _encoder.Pending()); _encoder.Pop("PRIVMSG #channel hello".Length);
} Assert.AreEqual("\r\n", _encoder.Pending());
}
[TestMethod] [TestMethod]
public void PopPartial() public void TestPopReturned()
{ {
var line = new Line("PRIVMSG #channel hello"); var line = new Line("PRIVMSG #channel hello");
_encoder.Push(line); _encoder.Push(line);
_encoder.Pop("PRIVMSG #channel hello".Length); _encoder.Push(line);
Assert.AreEqual("\r\n", _encoder.Pending()); var lines = _encoder.Pop("PRIVMSG #channel hello\r\n".Length);
} Assert.AreEqual(1, lines.Count);
Assert.AreEqual(line, lines[0]);
}
[TestMethod] [TestMethod]
public void TestPopReturned() public void PopNoneReturned()
{ {
var line = new Line("PRIVMSG #channel hello"); var line = new Line("PRIVMSG #channel hello");
_encoder.Push(line); _encoder.Push(line);
_encoder.Push(line); var lines = _encoder.Pop(1);
var lines = _encoder.Pop("PRIVMSG #channel hello\r\n".Length); Assert.AreEqual(0, lines.Count);
Assert.AreEqual(1, lines.Count); }
Assert.AreEqual(line, lines[0]);
}
[TestMethod] [TestMethod]
public void PopNoneReturned() public void PopMultipleLines()
{ {
var line = new Line("PRIVMSG #channel hello"); var line1 = new Line("PRIVMSG #channel1 hello");
_encoder.Push(line); _encoder.Push(line1);
var lines = _encoder.Pop(1); var line2 = new Line("PRIVMSG #channel2 hello");
Assert.AreEqual(0, lines.Count); _encoder.Push(line2);
}
[TestMethod] var lines = _encoder.Pop(_encoder.Pending().Length);
public void PopMultipleLines() Assert.AreEqual(2, lines.Count);
{ Assert.AreEqual(string.Empty, _encoder.Pending());
var line1 = new Line("PRIVMSG #channel1 hello"); }
_encoder.Push(line1);
var line2 = new Line("PRIVMSG #channel2 hello");
_encoder.Push(line2);
var lines = _encoder.Pop(_encoder.Pending().Length); [TestMethod]
Assert.AreEqual(2, lines.Count); public void Clear()
Assert.AreEqual(string.Empty, _encoder.Pending()); {
} _encoder.Push(new("PRIVMSG #channel hello"));
_encoder.Clear();
Assert.AreEqual(string.Empty, _encoder.Pending());
}
[TestMethod] [TestMethod]
public void Clear() public void EncodingIso8859()
{ {
_encoder.Push(new("PRIVMSG #channel hello")); var iso8859 = Encoding.GetEncoding("iso-8859-1");
_encoder.Clear(); _encoder = new() {Encoding = iso8859};
Assert.AreEqual(string.Empty, _encoder.Pending()); _encoder.Push(new("PRIVMSG #channel :hello Ç"));
} CollectionAssert.AreEqual(iso8859.GetBytes("PRIVMSG #channel :hello Ç\r\n"), _encoder.PendingBytes);
[TestMethod]
public void EncodingIso8859()
{
var iso8859 = Encoding.GetEncoding("iso-8859-1");
_encoder = new() {Encoding = iso8859};
_encoder.Push(new("PRIVMSG #channel :hello Ç"));
CollectionAssert.AreEqual(iso8859.GetBytes("PRIVMSG #channel :hello Ç\r\n"), _encoder.PendingBytes);
}
} }
} }

219
IRCSharp.Tests/Tokenization/Tokenization.cs
View File

@ -1,134 +1,127 @@
using System.Collections.Generic; namespace IRCSharp.Tests.Tokenization;
using System.Linq;
using System.Text;
using IRCTokens;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace IRCSharp.Tests.Tokenization [TestClass]
public class Tokenization
{ {
[TestClass] [TestMethod]
public class Tokenization public void TagsMissing()
{ {
[TestMethod] var line = new Line("PRIVMSG #channel");
public void TagsMissing() Assert.IsNull(line.Tags);
{ }
var line = new Line("PRIVMSG #channel");
Assert.IsNull(line.Tags);
}
[TestMethod] [TestMethod]
public void TagsMissingValue() public void TagsMissingValue()
{ {
var line = new Line("@id= PRIVMSG #channel"); var line = new Line("@id= PRIVMSG #channel");
Assert.AreEqual(string.Empty, line.Tags["id"]); Assert.AreEqual(string.Empty, line.Tags["id"]);
} }
[TestMethod] [TestMethod]
public void TagsMissingEqual() public void TagsMissingEqual()
{ {
var line = new Line("@id PRIVMSG #channel"); var line = new Line("@id PRIVMSG #channel");
Assert.AreEqual(string.Empty, line.Tags["id"]); Assert.AreEqual(string.Empty, line.Tags["id"]);
} }
[TestMethod] [TestMethod]
public void TagsUnescape() public void TagsUnescape()
{ {
var line = new Line(@"@id=1\\\:\r\n\s2 PRIVMSG #channel"); var line = new Line(@"@id=1\\\:\r\n\s2 PRIVMSG #channel");
Assert.AreEqual("1\\;\r\n 2", line.Tags["id"]); Assert.AreEqual("1\\;\r\n 2", line.Tags["id"]);
} }
[TestMethod] [TestMethod]
public void TagsOverlap() public void TagsOverlap()
{ {
var line = new Line(@"@id=1\\\s\\s PRIVMSG #channel"); var line = new Line(@"@id=1\\\s\\s PRIVMSG #channel");
Assert.AreEqual("1\\ \\s", line.Tags["id"]); Assert.AreEqual(@"1\ \s", line.Tags["id"]);
} }
[TestMethod] [TestMethod]
public void TagsLoneEndSlash() public void TagsLoneEndSlash()
{ {
var line = new Line("@id=1\\ PRIVMSG #channel"); var line = new Line("@id=1\\ PRIVMSG #channel");
Assert.AreEqual("1", line.Tags["id"]); Assert.AreEqual("1", line.Tags["id"]);
} }
[TestMethod] [TestMethod]
public void SourceWithoutTags() public void SourceWithoutTags()
{ {
var line = new Line(":nick!user@host PRIVMSG #channel"); var line = new Line(":nick!user@host PRIVMSG #channel");
Assert.AreEqual("nick!user@host", line.Source); Assert.AreEqual("nick!user@host", line.Source);
} }
[TestMethod] [TestMethod]
public void SourceWithTags() public void SourceWithTags()
{ {
var line = new Line("@id=123 :nick!user@host PRIVMSG #channel"); var line = new Line("@id=123 :nick!user@host PRIVMSG #channel");
Assert.AreEqual("nick!user@host", line.Source); Assert.AreEqual("nick!user@host", line.Source);
} }
[TestMethod] [TestMethod]
public void SourceMissingWithoutTags() public void SourceMissingWithoutTags()
{ {
var line = new Line("PRIVMSG #channel"); var line = new Line("PRIVMSG #channel");
Assert.IsNull(line.Source); Assert.IsNull(line.Source);
} }
[TestMethod] [TestMethod]
public void SourceMissingWithTags() public void SourceMissingWithTags()
{ {
var line = new Line("@id=123 PRIVMSG #channel"); var line = new Line("@id=123 PRIVMSG #channel");
Assert.IsNull(line.Source); Assert.IsNull(line.Source);
} }
[TestMethod] [TestMethod]
public void Command() public void Command()
{ {
var line = new Line("privmsg #channel"); var line = new Line("privmsg #channel");
Assert.AreEqual("PRIVMSG", line.Command); Assert.AreEqual("PRIVMSG", line.Command);
} }
[TestMethod] [TestMethod]
public void ParamsTrailing() public void ParamsTrailing()
{ {
var line = new Line("PRIVMSG #channel :hello world"); var line = new Line("PRIVMSG #channel :hello world");
CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params); CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params);
} }
[TestMethod] [TestMethod]
public void ParamsOnlyTrailing() public void ParamsOnlyTrailing()
{ {
var line = new Line("PRIVMSG :hello world"); var line = new Line("PRIVMSG :hello world");
CollectionAssert.AreEqual(new List<string> {"hello world"}, line.Params); CollectionAssert.AreEqual(new List<string> {"hello world"}, line.Params);
} }
[TestMethod] [TestMethod]
public void ParamsMissing() public void ParamsMissing()
{ {
var line = new Line("PRIVMSG"); var line = new Line("PRIVMSG");
Assert.AreEqual("PRIVMSG", line.Command); Assert.AreEqual("PRIVMSG", line.Command);
CollectionAssert.AreEqual(new List<string>(), line.Params); CollectionAssert.AreEqual(new List<string>(), line.Params);
} }
[TestMethod] [TestMethod]
public void AllTokens() public void AllTokens()
{ {
var line = new Line("@id=123 :nick!user@host PRIVMSG #channel :hello world"); var line = new Line("@id=123 :nick!user@host PRIVMSG #channel :hello world");
CollectionAssert.AreEqual(new Dictionary<string, string> {{"id", "123"}}, line.Tags); CollectionAssert.AreEqual(new Dictionary<string, string> {{"id", "123"}}, line.Tags);
Assert.AreEqual("nick!user@host", line.Source); Assert.AreEqual("nick!user@host", line.Source);
Assert.AreEqual("PRIVMSG", line.Command); Assert.AreEqual("PRIVMSG", line.Command);
CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params); CollectionAssert.AreEqual(new List<string> {"#channel", "hello world"}, line.Params);
} }
[TestMethod] [TestMethod]
public void NulByte() public void NulByte()
{ {
var decoder = new IRCTokens.StatefulDecoder(); var decoder = new IRCTokens.StatefulDecoder();
var bytes = Encoding.UTF8.GetBytes(":nick!user@host PRIVMSG #channel :hello") var bytes = ":nick!user@host PRIVMSG #channel :hello"u8.ToArray()
.Concat(Encoding.UTF8.GetBytes("\0")) .Concat("\0"u8.ToArray())
.Concat(Encoding.UTF8.GetBytes("world")) .Concat("world"u8.ToArray())
.ToArray(); .ToArray();
var line = decoder.Push(bytes, bytes.Length).First(); var line = decoder.Push(bytes, bytes.Length).First();
CollectionAssert.AreEqual(new List<string> {"#channel", "hello"}, line.Params); CollectionAssert.AreEqual(new List<string> {"#channel", "hello"}, line.Params);
}
} }
} }

4
IRCTokens/Line.cs
View File

@ -212,10 +212,10 @@ namespace IRCTokens
foreach (var p in withoutLast) foreach (var p in withoutLast)
{ {
if (p.Contains(' ', StringComparison.Ordinal)) if (p.Contains(' ', StringComparison.Ordinal))
throw new ArgumentException(@"non-last parameters cannot have spaces", p); throw new ArgumentException("non-last parameters cannot have spaces", p);
if (p.StartsWith(':')) if (p.StartsWith(':'))
throw new ArgumentException(@"non-last parameters cannot start with colon", p); throw new ArgumentException("non-last parameters cannot start with colon", p);
} }
outs.AddRange(withoutLast); outs.AddRange(withoutLast);