From e3a1308a04f605ece5f1a8600dc69feb2ce24d27 Mon Sep 17 00:00:00 2001 From: Alexey Sokolov Date: Tue, 13 Feb 2018 08:11:00 +0000 Subject: [PATCH] Make order of EXPECT_EQ more natural, after upgrade to new GTest. --- test/BufferTest.cpp | 70 ++++---- test/ClientTest.cpp | 20 +-- test/ConfigTest.cpp | 4 +- test/IRCSockTest.cpp | 30 ++-- test/MessageTest.cpp | 420 +++++++++++++++++++++---------------------- test/ModulesTest.cpp | 154 ++++++++-------- test/NetworkTest.cpp | 16 +- test/NickTest.cpp | 20 +-- test/QueryTest.cpp | 18 +- test/StringTest.cpp | 98 +++++----- test/ThreadTest.cpp | 4 +- test/UserTest.cpp | 2 +- test/UtilsTest.cpp | 56 +++--- 13 files changed, 456 insertions(+), 456 deletions(-) diff --git a/test/BufferTest.cpp b/test/BufferTest.cpp index cece8f0b..81ea9f93 100644 --- a/test/BufferTest.cpp +++ b/test/BufferTest.cpp @@ -34,59 +34,59 @@ TEST_F(BufferTest, BufLine) { "hello there"); const CBufLine& line = buffer.GetBufLine(0); EXPECT_THAT(line.GetTags(), ContainerEq(MCString{{"key", "value"}})); - EXPECT_EQ(":nick PRIVMSG {target} {text}", line.GetFormat()); - EXPECT_EQ("hello there", line.GetText()); - EXPECT_EQ("PRIVMSG", line.GetCommand()); + EXPECT_EQ(line.GetFormat(), ":nick PRIVMSG {target} {text}"); + EXPECT_EQ(line.GetText(), "hello there"); + EXPECT_EQ(line.GetCommand(), "PRIVMSG"); } TEST_F(BufferTest, LineCount) { CBuffer buffer(123); - EXPECT_EQ(123u, buffer.GetLineCount()); + EXPECT_EQ(buffer.GetLineCount(), 123u); - EXPECT_EQ(500u, CZNC::Get().GetMaxBufferSize()); + EXPECT_EQ(CZNC::Get().GetMaxBufferSize(), 500u); EXPECT_FALSE(buffer.SetLineCount(1000, false)); - EXPECT_EQ(123u, buffer.GetLineCount()); + EXPECT_EQ(buffer.GetLineCount(), 123u); EXPECT_TRUE(buffer.SetLineCount(500, false)); - EXPECT_EQ(500u, buffer.GetLineCount()); + EXPECT_EQ(buffer.GetLineCount(), 500u); EXPECT_TRUE(buffer.SetLineCount(1000, true)); - EXPECT_EQ(1000u, buffer.GetLineCount()); + EXPECT_EQ(buffer.GetLineCount(), 1000u); } TEST_F(BufferTest, AddLine) { CBuffer buffer(2); EXPECT_TRUE(buffer.IsEmpty()); - EXPECT_EQ(0u, buffer.Size()); + EXPECT_EQ(buffer.Size(), 0u); - EXPECT_EQ(1u, buffer.AddLine(CMessage("PRIVMSG nick :msg1"))); + EXPECT_EQ(buffer.AddLine(CMessage("PRIVMSG nick :msg1")), 1u); EXPECT_FALSE(buffer.IsEmpty()); - EXPECT_EQ(1u, buffer.Size()); - EXPECT_EQ("PRIVMSG nick :msg1", buffer.GetBufLine(0).GetFormat()); + EXPECT_EQ(buffer.Size(), 1u); + EXPECT_EQ(buffer.GetBufLine(0).GetFormat(), "PRIVMSG nick :msg1"); - EXPECT_EQ(2u, buffer.AddLine(CMessage("PRIVMSG nick :msg2"))); + EXPECT_EQ(buffer.AddLine(CMessage("PRIVMSG nick :msg2")), 2u); EXPECT_FALSE(buffer.IsEmpty()); - EXPECT_EQ(2u, buffer.Size()); - EXPECT_EQ("PRIVMSG nick :msg1", buffer.GetBufLine(0).GetFormat()); - EXPECT_EQ("PRIVMSG nick :msg2", buffer.GetBufLine(1).GetFormat()); + EXPECT_EQ(buffer.Size(), 2u); + EXPECT_EQ(buffer.GetBufLine(0).GetFormat(), "PRIVMSG nick :msg1"); + EXPECT_EQ(buffer.GetBufLine(1).GetFormat(), "PRIVMSG nick :msg2"); - EXPECT_EQ(2u, buffer.AddLine(CMessage("PRIVMSG nick :msg3"))); + EXPECT_EQ(buffer.AddLine(CMessage("PRIVMSG nick :msg3")), 2u); EXPECT_FALSE(buffer.IsEmpty()); - EXPECT_EQ(2u, buffer.Size()); - EXPECT_EQ("PRIVMSG nick :msg2", buffer.GetBufLine(0).GetFormat()); - EXPECT_EQ("PRIVMSG nick :msg3", buffer.GetBufLine(1).GetFormat()); + EXPECT_EQ(buffer.Size(), 2u); + EXPECT_EQ(buffer.GetBufLine(0).GetFormat(), "PRIVMSG nick :msg2"); + EXPECT_EQ(buffer.GetBufLine(1).GetFormat(), "PRIVMSG nick :msg3"); buffer.SetLineCount(1); EXPECT_FALSE(buffer.IsEmpty()); - EXPECT_EQ(1u, buffer.Size()); - EXPECT_EQ("PRIVMSG nick :msg3", buffer.GetBufLine(0).GetFormat()); + EXPECT_EQ(buffer.Size(), 1u); + EXPECT_EQ(buffer.GetBufLine(0).GetFormat(), "PRIVMSG nick :msg3"); buffer.Clear(); EXPECT_TRUE(buffer.IsEmpty()); - EXPECT_EQ(0u, buffer.Size()); + EXPECT_EQ(buffer.Size(), 0u); buffer.SetLineCount(0); buffer.AddLine(CMessage("TEST")); EXPECT_TRUE(buffer.IsEmpty()); - EXPECT_EQ(0u, buffer.Size()); + EXPECT_EQ(buffer.Size(), 0u); } TEST_F(BufferTest, UpdateLine) { @@ -115,21 +115,21 @@ TEST_F(BufferTest, UpdateLine) { for (const CString& line : lines) { buffer.AddLine(line); } - EXPECT_EQ(15u, buffer.Size()); + EXPECT_EQ(buffer.Size(), 15u); - EXPECT_EQ(15u, buffer.UpdateLine("002", CMessage(":irc.server.net 002 nick :Your host is irc.server.net[11.22.33.44/6697], running version ircd-fake-3.2.1"))); - EXPECT_EQ(":irc.server.net 002 nick :Your host is irc.server.net[11.22.33.44/6697], running version ircd-fake-3.2.1", buffer.GetBufLine(1).GetFormat()); + EXPECT_EQ(buffer.UpdateLine("002", CMessage(":irc.server.net 002 nick :Your host is irc.server.net[11.22.33.44/6697], running version ircd-fake-3.2.1")), 15u); + EXPECT_EQ(buffer.GetBufLine(1).GetFormat(), ":irc.server.net 002 nick :Your host is irc.server.net[11.22.33.44/6697], running version ircd-fake-3.2.1"); - EXPECT_EQ(15u, buffer.UpdateLine("252", CMessage(":irc.server.com 252 nick 100 :IRC Operators online"))); - EXPECT_EQ(":irc.server.com 252 nick 100 :IRC Operators online", buffer.GetBufLine(8).GetFormat()); + EXPECT_EQ(buffer.UpdateLine("252", CMessage(":irc.server.com 252 nick 100 :IRC Operators online")), 15u); + EXPECT_EQ(buffer.GetBufLine(8).GetFormat(), ":irc.server.com 252 nick 100 :IRC Operators online"); - EXPECT_EQ(16u, buffer.UpdateLine("123", CMessage(":irc.server.com 123 nick foo bar"))); - EXPECT_EQ(":irc.server.com 123 nick foo bar", buffer.GetBufLine(15).GetFormat()); + EXPECT_EQ(buffer.UpdateLine("123", CMessage(":irc.server.com 123 nick foo bar")), 16u); + EXPECT_EQ(buffer.GetBufLine(15).GetFormat(), ":irc.server.com 123 nick foo bar"); - EXPECT_EQ(16u, buffer.UpdateExactLine(CMessage(":irc.server.com 005 nick EXTBAN=$,ajrxz WHOX CLIENTVER=3.0 SAFELIST ELIST=CTU :are supported by this server"))); - EXPECT_EQ(":irc.server.com 005 nick EXTBAN=$,ajrxz WHOX CLIENTVER=3.0 SAFELIST ELIST=CTU :are supported by this server", buffer.GetBufLine(6).GetFormat()); + EXPECT_EQ(buffer.UpdateExactLine(CMessage(":irc.server.com 005 nick EXTBAN=$,ajrxz WHOX CLIENTVER=3.0 SAFELIST ELIST=CTU :are supported by this server")), 16u); + EXPECT_EQ(buffer.GetBufLine(6).GetFormat(), ":irc.server.com 005 nick EXTBAN=$,ajrxz WHOX CLIENTVER=3.0 SAFELIST ELIST=CTU :are supported by this server"); - EXPECT_EQ(17u, buffer.UpdateExactLine(CMessage(":irc.server.com 005 nick FOO=bar :are supported by this server"))); - EXPECT_EQ(":irc.server.com 005 nick FOO=bar :are supported by this server", buffer.GetBufLine(16).GetFormat()); + EXPECT_EQ(buffer.UpdateExactLine(CMessage(":irc.server.com 005 nick FOO=bar :are supported by this server")), 17u); + EXPECT_EQ(buffer.GetBufLine(16).GetFormat(), ":irc.server.com 005 nick FOO=bar :are supported by this server"); // clang-format on } diff --git a/test/ClientTest.cpp b/test/ClientTest.cpp index b844a24c..8a55ad88 100644 --- a/test/ClientTest.cpp +++ b/test/ClientTest.cpp @@ -28,19 +28,19 @@ class ClientTest : public IRCTest { const CString& sPass) const { CClient client; client.ParsePass(sInput); - EXPECT_EQ(sUser, client.m_sUser); - EXPECT_EQ(sIdentifier, client.m_sIdentifier); - EXPECT_EQ(sNetwork, client.m_sNetwork); - EXPECT_EQ(sPass, client.m_sPass); + EXPECT_EQ(client.m_sUser, sUser); + EXPECT_EQ(client.m_sIdentifier, sIdentifier); + EXPECT_EQ(client.m_sNetwork, sNetwork); + EXPECT_EQ(client.m_sPass, sPass); } void testUser(const CString& sInput, const CString& sUser, const CString& sIdentifier, const CString& sNetwork) const { CClient client; client.ParseUser(sInput); - EXPECT_EQ(sUser, client.m_sUser); - EXPECT_EQ(sIdentifier, client.m_sIdentifier); - EXPECT_EQ(sNetwork, client.m_sNetwork); + EXPECT_EQ(client.m_sUser, sUser); + EXPECT_EQ(client.m_sIdentifier, sIdentifier); + EXPECT_EQ(client.m_sNetwork, sNetwork); } }; @@ -181,11 +181,11 @@ TEST_F(ClientTest, StatusMsg) { m_pTestUser->SetAutoClearChanBuffer(false); m_pTestClient->ReadLine("PRIVMSG @#chan :hello ops"); - EXPECT_EQ(1u, m_pTestChan->GetBuffer().Size()); + EXPECT_EQ(m_pTestChan->GetBuffer().Size(), 1u); m_pTestUser->SetTimestampPrepend(false); - EXPECT_EQ(":me PRIVMSG @#chan :hello ops", - m_pTestChan->GetBuffer().GetLine(0, *m_pTestClient)); + EXPECT_EQ(m_pTestChan->GetBuffer().GetLine(0, *m_pTestClient), + ":me PRIVMSG @#chan :hello ops"); } TEST_F(ClientTest, TagSupport) { diff --git a/test/ConfigTest.cpp b/test/ConfigTest.cpp index 941257d3..71dc6e11 100644 --- a/test/ConfigTest.cpp +++ b/test/ConfigTest.cpp @@ -47,7 +47,7 @@ class CConfigErrorTest : public CConfigTest { CString sError; EXPECT_FALSE(conf.Parse(File, sError)); - EXPECT_EQ(sExpectError, sError); + EXPECT_EQ(sError, sExpectError); } }; @@ -66,7 +66,7 @@ class CConfigSuccessTest : public CConfigTest { CString sOutput; ToString(sOutput, conf); - EXPECT_EQ(sExpectedOutput, sOutput); + EXPECT_EQ(sOutput, sExpectedOutput); } void ToString(CString& sRes, CConfig& conf) { diff --git a/test/IRCSockTest.cpp b/test/IRCSockTest.cpp index 38cbd6c5..3a116ed4 100644 --- a/test/IRCSockTest.cpp +++ b/test/IRCSockTest.cpp @@ -65,15 +65,15 @@ TEST_F(IRCSockTest, OnActionMessage) { CMessage msg(":nick PRIVMSG #chan :\001ACTION hello\001"); auto CON = Invoke([&](CMessage& m) { - EXPECT_EQ(msg.ToString(), m.ToString()); - EXPECT_EQ(m_pTestNetwork, m.GetNetwork()); - EXPECT_EQ(pExpectedChan, m.GetChan()); + EXPECT_EQ(m.ToString(), msg.ToString()); + EXPECT_EQ(m.GetNetwork(), m_pTestNetwork); + EXPECT_EQ(m.GetChan(), pExpectedChan); return CModule::CONTINUE; }); auto HAL = Invoke([&](CMessage& m) { - EXPECT_EQ(msg.ToString(), m.ToString()); - EXPECT_EQ(m_pTestNetwork, m.GetNetwork()); - EXPECT_EQ(pExpectedChan, m.GetChan()); + EXPECT_EQ(m.ToString(), msg.ToString()); + EXPECT_EQ(m.GetNetwork(), m_pTestNetwork); + EXPECT_EQ(m.GetChan(), pExpectedChan); return CModule::HALT; }); auto Reset = [&]() { @@ -458,7 +458,7 @@ TEST_F(IRCSockTest, ISupport) { ":are supported by this server"); EXPECT_THAT(m_pTestSock->GetISupport(), ContainerEq(m1)); for (const auto& it : m1) { - EXPECT_EQ(it.second, m_pTestSock->GetISupport(it.first)); + EXPECT_EQ(m_pTestSock->GetISupport(it.first), it.second); } MCString m2 = { @@ -489,7 +489,7 @@ TEST_F(IRCSockTest, ISupport) { "MONITOR: :are supported by this server"); EXPECT_THAT(m_pTestSock->GetISupport(), ContainerEq(m12)); for (const auto& it : m2) { - EXPECT_EQ(it.second, m_pTestSock->GetISupport(it.first)); + EXPECT_EQ(m_pTestSock->GetISupport(it.first), it.second); } MCString m3 = { @@ -506,12 +506,12 @@ TEST_F(IRCSockTest, ISupport) { "ELIST=CTU :are supported by this server"); EXPECT_THAT(m_pTestSock->GetISupport(), ContainerEq(m123)); for (const auto& it : m3) { - EXPECT_EQ(it.second, m_pTestSock->GetISupport(it.first)); + EXPECT_EQ(m_pTestSock->GetISupport(it.first), it.second); } - EXPECT_EQ("default", m_pTestSock->GetISupport("FOOBAR", "default")); - EXPECT_EQ("3.0", m_pTestSock->GetISupport("CLIENTVER", "default")); - EXPECT_EQ("", m_pTestSock->GetISupport("SAFELIST", "default")); + EXPECT_EQ(m_pTestSock->GetISupport("FOOBAR", "default"), "default"); + EXPECT_EQ(m_pTestSock->GetISupport("CLIENTVER", "default"), "3.0"); + EXPECT_EQ(m_pTestSock->GetISupport("SAFELIST", "default"), ""); } TEST_F(IRCSockTest, StatusMsg) { @@ -524,9 +524,9 @@ TEST_F(IRCSockTest, StatusMsg) { m_pTestUser->SetAutoClearChanBuffer(false); m_pTestSock->ReadLine(":someone PRIVMSG @#chan :hello ops"); - EXPECT_EQ(1u, m_pTestChan->GetBuffer().Size()); + EXPECT_EQ(m_pTestChan->GetBuffer().Size(), 1u); m_pTestUser->SetTimestampPrepend(false); - EXPECT_EQ(":someone PRIVMSG @#chan :hello ops", - m_pTestChan->GetBuffer().GetLine(0, *m_pTestClient)); + EXPECT_EQ(m_pTestChan->GetBuffer().GetLine(0, *m_pTestClient), + ":someone PRIVMSG @#chan :hello ops"); } diff --git a/test/MessageTest.cpp b/test/MessageTest.cpp index f5c2cc0f..37a0eb63 100644 --- a/test/MessageTest.cpp +++ b/test/MessageTest.cpp @@ -37,68 +37,68 @@ TEST(MessageTest, SetParam) { } TEST(MessageTest, GetParams) { - EXPECT_EQ("", CMessage("CMD").GetParams(0)); - EXPECT_EQ("", CMessage("CMD").GetParams(1)); - EXPECT_EQ("", CMessage("CMD").GetParams(-1)); + EXPECT_EQ(CMessage("CMD").GetParams(0), ""); + EXPECT_EQ(CMessage("CMD").GetParams(1), ""); + EXPECT_EQ(CMessage("CMD").GetParams(-1), ""); - EXPECT_EQ("", CMessage("CMD").GetParams(0, 0)); - EXPECT_EQ("", CMessage("CMD").GetParams(1, 0)); - EXPECT_EQ("", CMessage("CMD").GetParams(-1, 0)); + EXPECT_EQ(CMessage("CMD").GetParams(0, 0), ""); + EXPECT_EQ(CMessage("CMD").GetParams(1, 0), ""); + EXPECT_EQ(CMessage("CMD").GetParams(-1, 0), ""); - EXPECT_EQ("", CMessage("CMD").GetParams(0, 1)); - EXPECT_EQ("", CMessage("CMD").GetParams(1, 1)); - EXPECT_EQ("", CMessage("CMD").GetParams(-1, 1)); + EXPECT_EQ(CMessage("CMD").GetParams(0, 1), ""); + EXPECT_EQ(CMessage("CMD").GetParams(1, 1), ""); + EXPECT_EQ(CMessage("CMD").GetParams(-1, 1), ""); - EXPECT_EQ("", CMessage("CMD").GetParams(0, 10)); - EXPECT_EQ("", CMessage("CMD").GetParams(1, 10)); - EXPECT_EQ("", CMessage("CMD").GetParams(-1, 10)); + EXPECT_EQ(CMessage("CMD").GetParams(0, 10), ""); + EXPECT_EQ(CMessage("CMD").GetParams(1, 10), ""); + EXPECT_EQ(CMessage("CMD").GetParams(-1, 10), ""); - EXPECT_EQ("p1 :p2 p3", CMessage("CMD p1 :p2 p3").GetParams(0)); - EXPECT_EQ(":p2 p3", CMessage("CMD p1 :p2 p3").GetParams(1)); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(-1)); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(0), "p1 :p2 p3"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(1), ":p2 p3"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(-1), ""); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(0, 0)); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(1, 0)); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(-1, 0)); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(0, 0), ""); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(1, 0), ""); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(-1, 0), ""); - EXPECT_EQ("p1", CMessage("CMD p1 :p2 p3").GetParams(0, 1)); - EXPECT_EQ(":p2 p3", CMessage("CMD p1 :p2 p3").GetParams(1, 1)); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(-1, 1)); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(0, 1), "p1"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(1, 1), ":p2 p3"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(-1, 1), ""); - EXPECT_EQ("p1 :p2 p3", CMessage("CMD p1 :p2 p3").GetParams(0, 10)); - EXPECT_EQ(":p2 p3", CMessage("CMD p1 :p2 p3").GetParams(1, 10)); - EXPECT_EQ("", CMessage("CMD p1 :p2 p3").GetParams(-1, 10)); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(0, 10), "p1 :p2 p3"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(1, 10), ":p2 p3"); + EXPECT_EQ(CMessage("CMD p1 :p2 p3").GetParams(-1, 10), ""); } TEST(MessageTest, ToString) { - EXPECT_EQ("CMD", CMessage("CMD").ToString()); - EXPECT_EQ("CMD p1", CMessage("CMD p1").ToString()); - EXPECT_EQ("CMD p1 p2", CMessage("CMD p1 p2").ToString()); - EXPECT_EQ("CMD :p p p", CMessage("CMD :p p p").ToString()); - EXPECT_EQ(":irc.znc.in", CMessage(":irc.znc.in").ToString()); - EXPECT_EQ(":irc.znc.in CMD", CMessage(":irc.znc.in CMD").ToString()); - EXPECT_EQ(":irc.znc.in CMD p1", CMessage(":irc.znc.in CMD p1").ToString()); - EXPECT_EQ(":irc.znc.in CMD p1 p2", - CMessage(":irc.znc.in CMD p1 p2").ToString()); - EXPECT_EQ(":irc.znc.in CMD :p p p", - CMessage(":irc.znc.in CMD :p p p").ToString()); - EXPECT_EQ(":irc.znc.in CMD :", CMessage(":irc.znc.in CMD :").ToString()); + EXPECT_EQ(CMessage("CMD").ToString(), "CMD"); + EXPECT_EQ(CMessage("CMD p1").ToString(), "CMD p1"); + EXPECT_EQ(CMessage("CMD p1 p2").ToString(), "CMD p1 p2"); + EXPECT_EQ(CMessage("CMD :p p p").ToString(), "CMD :p p p"); + EXPECT_EQ(CMessage(":irc.znc.in").ToString(), ":irc.znc.in"); + EXPECT_EQ(CMessage(":irc.znc.in CMD").ToString(), ":irc.znc.in CMD"); + EXPECT_EQ(CMessage(":irc.znc.in CMD p1").ToString(), ":irc.znc.in CMD p1"); + EXPECT_EQ(CMessage(":irc.znc.in CMD p1 p2").ToString(), + ":irc.znc.in CMD p1 p2"); + EXPECT_EQ(CMessage(":irc.znc.in CMD :p p p").ToString(), + ":irc.znc.in CMD :p p p"); + EXPECT_EQ(CMessage(":irc.znc.in CMD :").ToString(), ":irc.znc.in CMD :"); - EXPECT_EQ("CMD", CMessage(CNick(), "CMD").ToString()); - EXPECT_EQ("CMD p1", CMessage(CNick(), "CMD", {"p1"}).ToString()); - EXPECT_EQ("CMD p1 p2", CMessage(CNick(), "CMD", {"p1", "p2"}).ToString()); - EXPECT_EQ("CMD :p p p", CMessage(CNick(), "CMD", {"p p p"}).ToString()); - EXPECT_EQ(":irc.znc.in", CMessage(CNick(":irc.znc.in"), "").ToString()); - EXPECT_EQ(":irc.znc.in CMD", - CMessage(CNick(":irc.znc.in"), "CMD").ToString()); - EXPECT_EQ(":irc.znc.in CMD p1", - CMessage(CNick(":irc.znc.in"), "CMD", {"p1"}).ToString()); - EXPECT_EQ(":irc.znc.in CMD p1 p2", - CMessage(CNick(":irc.znc.in"), "CMD", {"p1", "p2"}).ToString()); - EXPECT_EQ(":irc.znc.in CMD :p p p", - CMessage(CNick(":irc.znc.in"), "CMD", {"p p p"}).ToString()); - EXPECT_EQ(":irc.znc.in CMD :", - CMessage(CNick(":irc.znc.in"), "CMD", {""}).ToString()); + EXPECT_EQ(CMessage(CNick(), "CMD").ToString(), "CMD"); + EXPECT_EQ(CMessage(CNick(), "CMD", {"p1"}).ToString(), "CMD p1"); + EXPECT_EQ(CMessage(CNick(), "CMD", {"p1", "p2"}).ToString(), "CMD p1 p2"); + EXPECT_EQ(CMessage(CNick(), "CMD", {"p p p"}).ToString(), "CMD :p p p"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "").ToString(), ":irc.znc.in"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "CMD").ToString(), + ":irc.znc.in CMD"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "CMD", {"p1"}).ToString(), + ":irc.znc.in CMD p1"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "CMD", {"p1", "p2"}).ToString(), + ":irc.znc.in CMD p1 p2"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "CMD", {"p p p"}).ToString(), + ":irc.znc.in CMD :p p p"); + EXPECT_EQ(CMessage(CNick(":irc.znc.in"), "CMD", {""}).ToString(), + ":irc.znc.in CMD :"); // #1045 - retain the colon if it was there EXPECT_EQ(":services. 328 user #chan http://znc.in", @@ -145,13 +145,13 @@ TEST(MessageTest, Tags) { CMessage msg(":rest"); msg.SetTags({{"a", "b"}}); - EXPECT_EQ("@a=b :rest", msg.ToString()); + EXPECT_EQ(msg.ToString(), "@a=b :rest"); msg.SetTags({{"a", "b"}, {"c", "d"}}); - EXPECT_EQ("@a=b;c=d :rest", msg.ToString()); + EXPECT_EQ(msg.ToString(), "@a=b;c=d :rest"); msg.SetTags({{"a", "b"}, {"c", "d"}, {"e", ""}}); - EXPECT_EQ("@a=b;c=d;e :rest", msg.ToString()); + EXPECT_EQ(msg.ToString(), "@a=b;c=d;e :rest"); msg.SetTags({{"semi-colon", ";"}, {"space", " "}, @@ -160,23 +160,23 @@ TEST(MessageTest, Tags) { {"CR", {'\r'}}, {"LF", {'\n'}}}); EXPECT_EQ( - R"(@CR=\r;LF=\n;NUL=\0;backslash=\\;semi-colon=\:;space=\s :rest)", - msg.ToString()); + msg.ToString(), + R"(@CR=\r;LF=\n;NUL=\0;backslash=\\;semi-colon=\:;space=\s :rest)"); msg.SetTags({{"a", "; \\\r\n"}}); - EXPECT_EQ(R"(@a=\:\s\\\r\n :rest)", msg.ToString()); + EXPECT_EQ(msg.ToString(), R"(@a=\:\s\\\r\n :rest)"); } TEST(MessageTest, FormatFlags) { const CString line = "@foo=bar :irc.example.com COMMAND param"; CMessage msg(line); - EXPECT_EQ(line, msg.ToString()); - EXPECT_EQ(":irc.example.com COMMAND param", - msg.ToString(CMessage::ExcludeTags)); - EXPECT_EQ("@foo=bar COMMAND param", msg.ToString(CMessage::ExcludePrefix)); - EXPECT_EQ("COMMAND param", - msg.ToString(CMessage::ExcludePrefix | CMessage::ExcludeTags)); + EXPECT_EQ(msg.ToString(), line); + EXPECT_EQ(msg.ToString(CMessage::ExcludeTags), + ":irc.example.com COMMAND param"); + EXPECT_EQ(msg.ToString(CMessage::ExcludePrefix), "@foo=bar COMMAND param"); + EXPECT_EQ(msg.ToString(CMessage::ExcludePrefix | CMessage::ExcludeTags), + "COMMAND param"); } TEST(MessageTest, Equals) { @@ -211,264 +211,264 @@ TEST(MessageTest, Equals) { } TEST(MessageTest, Type) { - EXPECT_EQ(CMessage::Type::Unknown, CMessage("FOO").GetType()); - EXPECT_EQ(CMessage::Type::Account, CMessage("ACCOUNT").GetType()); - EXPECT_EQ(CMessage::Type::Away, CMessage("AWAY").GetType()); - EXPECT_EQ(CMessage::Type::Capability, CMessage("CAP").GetType()); - EXPECT_EQ(CMessage::Type::Error, CMessage("ERROR").GetType()); - EXPECT_EQ(CMessage::Type::Invite, CMessage("INVITE").GetType()); - EXPECT_EQ(CMessage::Type::Join, CMessage("JOIN").GetType()); - EXPECT_EQ(CMessage::Type::Kick, CMessage("KICK").GetType()); - EXPECT_EQ(CMessage::Type::Mode, CMessage("MODE").GetType()); - EXPECT_EQ(CMessage::Type::Nick, CMessage("NICK").GetType()); - EXPECT_EQ(CMessage::Type::Notice, CMessage("NOTICE").GetType()); - EXPECT_EQ(CMessage::Type::Numeric, CMessage("123").GetType()); - EXPECT_EQ(CMessage::Type::Part, CMessage("PART").GetType()); - EXPECT_EQ(CMessage::Type::Ping, CMessage("PING").GetType()); - EXPECT_EQ(CMessage::Type::Pong, CMessage("PONG").GetType()); - EXPECT_EQ(CMessage::Type::Quit, CMessage("QUIT").GetType()); - EXPECT_EQ(CMessage::Type::Text, CMessage("PRIVMSG").GetType()); - EXPECT_EQ(CMessage::Type::Topic, CMessage("TOPIC").GetType()); - EXPECT_EQ(CMessage::Type::Wallops, CMessage("WALLOPS").GetType()); + EXPECT_EQ(CMessage("FOO").GetType(), CMessage::Type::Unknown); + EXPECT_EQ(CMessage("ACCOUNT").GetType(), CMessage::Type::Account); + EXPECT_EQ(CMessage("AWAY").GetType(), CMessage::Type::Away); + EXPECT_EQ(CMessage("CAP").GetType(), CMessage::Type::Capability); + EXPECT_EQ(CMessage("ERROR").GetType(), CMessage::Type::Error); + EXPECT_EQ(CMessage("INVITE").GetType(), CMessage::Type::Invite); + EXPECT_EQ(CMessage("JOIN").GetType(), CMessage::Type::Join); + EXPECT_EQ(CMessage("KICK").GetType(), CMessage::Type::Kick); + EXPECT_EQ(CMessage("MODE").GetType(), CMessage::Type::Mode); + EXPECT_EQ(CMessage("NICK").GetType(), CMessage::Type::Nick); + EXPECT_EQ(CMessage("NOTICE").GetType(), CMessage::Type::Notice); + EXPECT_EQ(CMessage("123").GetType(), CMessage::Type::Numeric); + EXPECT_EQ(CMessage("PART").GetType(), CMessage::Type::Part); + EXPECT_EQ(CMessage("PING").GetType(), CMessage::Type::Ping); + EXPECT_EQ(CMessage("PONG").GetType(), CMessage::Type::Pong); + EXPECT_EQ(CMessage("QUIT").GetType(), CMessage::Type::Quit); + EXPECT_EQ(CMessage("PRIVMSG").GetType(), CMessage::Type::Text); + EXPECT_EQ(CMessage("TOPIC").GetType(), CMessage::Type::Topic); + EXPECT_EQ(CMessage("WALLOPS").GetType(), CMessage::Type::Wallops); CMessage msg; - EXPECT_EQ(CMessage::Type::Unknown, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::Unknown); msg.SetCommand("PRIVMSG"); - EXPECT_EQ(CMessage::Type::Text, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::Text); msg.SetParams({"target", "\001ACTION foo\001"}); - EXPECT_EQ(CMessage::Type::Action, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::Action); msg.SetParam(1, "\001foo\001"); - EXPECT_EQ(CMessage::Type::CTCP, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::CTCP); msg.SetCommand("NOTICE"); - EXPECT_EQ(CMessage::Type::CTCP, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::CTCP); msg.SetParam(1, "foo"); - EXPECT_EQ(CMessage::Type::Notice, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::Notice); } TEST(MessageTest, Target) { CTargetMessage msg; msg.Parse(":sender PRIVMSG #chan :foo bar"); - EXPECT_EQ("#chan", msg.GetTarget()); + EXPECT_EQ(msg.GetTarget(), "#chan"); msg.SetTarget("#znc"); - EXPECT_EQ("#znc", msg.GetTarget()); - EXPECT_EQ(":sender PRIVMSG #znc :foo bar", msg.ToString()); + EXPECT_EQ(msg.GetTarget(), "#znc"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG #znc :foo bar"); } TEST(MessageTest, ChanAction) { CActionMessage msg; msg.Parse(":sender PRIVMSG #chan :\001ACTION ACTS\001"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("ACTS", msg.GetText()); - EXPECT_EQ(CMessage::Type::Action, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetText(), "ACTS"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Action); msg.SetText("foo bar"); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG #chan :\001ACTION foo bar\001", msg.ToString()); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG #chan :\001ACTION foo bar\001"); } TEST(MessageTest, ChanCTCP) { CCTCPMessage msg; msg.Parse(":sender PRIVMSG #chan :\001text\001"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("text", msg.GetText()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetText(), "text"); EXPECT_FALSE(msg.IsReply()); - EXPECT_EQ(CMessage::Type::CTCP, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::CTCP); msg.SetText("foo bar"); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG #chan :\001foo bar\001", msg.ToString()); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG #chan :\001foo bar\001"); } TEST(MessageTest, ChanMsg) { CTextMessage msg; msg.Parse(":sender PRIVMSG #chan :text"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("text", msg.GetText()); - EXPECT_EQ(CMessage::Type::Text, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetText(), "text"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Text); msg.SetText("foo bar"); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG #chan :foo bar", msg.ToString()); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG #chan :foo bar"); } TEST(MessageTest, CTCPReply) { CCTCPMessage msg; msg.Parse(":sender NOTICE nick :\001FOO bar\001"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("NOTICE", msg.GetCommand()); - EXPECT_EQ("nick", msg.GetTarget()); - EXPECT_EQ("FOO bar", msg.GetText()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "NOTICE"); + EXPECT_EQ(msg.GetTarget(), "nick"); + EXPECT_EQ(msg.GetText(), "FOO bar"); EXPECT_TRUE(msg.IsReply()); - EXPECT_EQ(CMessage::Type::CTCP, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::CTCP); msg.SetText("BAR foo"); - EXPECT_EQ("BAR foo", msg.GetText()); - EXPECT_EQ(":sender NOTICE nick :\001BAR foo\001", msg.ToString()); + EXPECT_EQ(msg.GetText(), "BAR foo"); + EXPECT_EQ(msg.ToString(), ":sender NOTICE nick :\001BAR foo\001"); } TEST(MessageTest, Kick) { CKickMessage msg; msg.Parse(":nick KICK #chan person :reason"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("KICK", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("person", msg.GetKickedNick()); - EXPECT_EQ("reason", msg.GetReason()); - EXPECT_EQ(CMessage::Type::Kick, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "KICK"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetKickedNick(), "person"); + EXPECT_EQ(msg.GetReason(), "reason"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Kick); msg.SetKickedNick("noone"); - EXPECT_EQ("noone", msg.GetKickedNick()); + EXPECT_EQ(msg.GetKickedNick(), "noone"); msg.SetReason("test"); - EXPECT_EQ("test", msg.GetReason()); - EXPECT_EQ(":nick KICK #chan noone :test", msg.ToString()); + EXPECT_EQ(msg.GetReason(), "test"); + EXPECT_EQ(msg.ToString(), ":nick KICK #chan noone :test"); } TEST(MessageTest, Join) { CJoinMessage msg; msg.Parse(":nick JOIN #chan"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("JOIN", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ(CMessage::Type::Join, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "JOIN"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Join); - EXPECT_EQ(":nick JOIN #chan", msg.ToString()); + EXPECT_EQ(msg.ToString(), ":nick JOIN #chan"); } TEST(MessageTest, Mode) { CModeMessage msg; msg.Parse(":nick MODE #chan +k foo"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("MODE", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("+k foo", msg.GetModes()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "MODE"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetModes(), "+k foo"); - EXPECT_EQ(":nick MODE #chan +k foo", msg.ToString()); + EXPECT_EQ(msg.ToString(), ":nick MODE #chan +k foo"); msg.Parse(":nick MODE nick :+i"); - EXPECT_EQ("+i", msg.GetModes()); + EXPECT_EQ(msg.GetModes(), "+i"); - EXPECT_EQ(":nick MODE nick :+i", msg.ToString()); + EXPECT_EQ(msg.ToString(), ":nick MODE nick :+i"); } TEST(MessageTest, Nick) { CNickMessage msg; msg.Parse(":nick NICK person"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("NICK", msg.GetCommand()); - EXPECT_EQ("nick", msg.GetOldNick()); - EXPECT_EQ("person", msg.GetNewNick()); - EXPECT_EQ(CMessage::Type::Nick, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "NICK"); + EXPECT_EQ(msg.GetOldNick(), "nick"); + EXPECT_EQ(msg.GetNewNick(), "person"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Nick); msg.SetNewNick("test"); - EXPECT_EQ("test", msg.GetNewNick()); - EXPECT_EQ(":nick NICK test", msg.ToString()); + EXPECT_EQ(msg.GetNewNick(), "test"); + EXPECT_EQ(msg.ToString(), ":nick NICK test"); } TEST(MessageTest, Numeric) { CNumericMessage msg; msg.Parse(":server 123 user :foo bar"); - EXPECT_EQ("server", msg.GetNick().GetNick()); - EXPECT_EQ("123", msg.GetCommand()); - EXPECT_EQ(123u, msg.GetCode()); - EXPECT_EQ(CMessage::Type::Numeric, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "server"); + EXPECT_EQ(msg.GetCommand(), "123"); + EXPECT_EQ(msg.GetCode(), 123u); + EXPECT_EQ(msg.GetType(), CMessage::Type::Numeric); - EXPECT_EQ(":server 123 user :foo bar", msg.ToString()); + EXPECT_EQ(msg.ToString(), ":server 123 user :foo bar"); } TEST(MessageTest, Part) { CPartMessage msg; msg.Parse(":nick PART #chan :reason"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("PART", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("reason", msg.GetReason()); - EXPECT_EQ(CMessage::Type::Part, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "PART"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetReason(), "reason"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Part); msg.SetReason("test"); - EXPECT_EQ("test", msg.GetReason()); - EXPECT_EQ(":nick PART #chan :test", msg.ToString()); + EXPECT_EQ(msg.GetReason(), "test"); + EXPECT_EQ(msg.ToString(), ":nick PART #chan :test"); } TEST(MessageTest, PrivAction) { CActionMessage msg; msg.Parse(":sender PRIVMSG receiver :\001ACTION ACTS\001"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("receiver", msg.GetTarget()); - EXPECT_EQ("ACTS", msg.GetText()); - EXPECT_EQ(CMessage::Type::Action, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "receiver"); + EXPECT_EQ(msg.GetText(), "ACTS"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Action); msg.SetText("foo bar"); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG receiver :\001ACTION foo bar\001", - msg.ToString()); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.ToString(), + ":sender PRIVMSG receiver :\001ACTION foo bar\001"); } TEST(MessageTest, PrivCTCP) { CCTCPMessage msg; msg.Parse(":sender PRIVMSG receiver :\001text\001"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("receiver", msg.GetTarget()); - EXPECT_EQ("text", msg.GetText()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "receiver"); + EXPECT_EQ(msg.GetText(), "text"); EXPECT_FALSE(msg.IsReply()); - EXPECT_EQ(CMessage::Type::CTCP, msg.GetType()); + EXPECT_EQ(msg.GetType(), CMessage::Type::CTCP); msg.SetText("foo bar"); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG receiver :\001foo bar\001", msg.ToString()); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG receiver :\001foo bar\001"); } TEST(MessageTest, PrivMsg) { CTextMessage msg; msg.Parse(":sender PRIVMSG receiver :foo bar"); - EXPECT_EQ("sender", msg.GetNick().GetNick()); - EXPECT_EQ("PRIVMSG", msg.GetCommand()); - EXPECT_EQ("receiver", msg.GetTarget()); - EXPECT_EQ("foo bar", msg.GetText()); - EXPECT_EQ(CMessage::Type::Text, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "sender"); + EXPECT_EQ(msg.GetCommand(), "PRIVMSG"); + EXPECT_EQ(msg.GetTarget(), "receiver"); + EXPECT_EQ(msg.GetText(), "foo bar"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Text); msg.SetText(":)"); - EXPECT_EQ(":)", msg.GetText()); - EXPECT_EQ(":sender PRIVMSG receiver ::)", msg.ToString()); + EXPECT_EQ(msg.GetText(), ":)"); + EXPECT_EQ(msg.ToString(), ":sender PRIVMSG receiver ::)"); } TEST(MessageTest, Quit) { CQuitMessage msg; msg.Parse(":nick QUIT :reason"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("QUIT", msg.GetCommand()); - EXPECT_EQ("reason", msg.GetReason()); - EXPECT_EQ(CMessage::Type::Quit, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "QUIT"); + EXPECT_EQ(msg.GetReason(), "reason"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Quit); msg.SetReason("test"); - EXPECT_EQ("test", msg.GetReason()); - EXPECT_EQ(":nick QUIT :test", msg.ToString()); + EXPECT_EQ(msg.GetReason(), "test"); + EXPECT_EQ(msg.ToString(), ":nick QUIT :test"); } TEST(MessageTest, Topic) { CTopicMessage msg; msg.Parse(":nick TOPIC #chan :topic"); - EXPECT_EQ("nick", msg.GetNick().GetNick()); - EXPECT_EQ("TOPIC", msg.GetCommand()); - EXPECT_EQ("#chan", msg.GetTarget()); - EXPECT_EQ("topic", msg.GetTopic()); - EXPECT_EQ(CMessage::Type::Topic, msg.GetType()); + EXPECT_EQ(msg.GetNick().GetNick(), "nick"); + EXPECT_EQ(msg.GetCommand(), "TOPIC"); + EXPECT_EQ(msg.GetTarget(), "#chan"); + EXPECT_EQ(msg.GetTopic(), "topic"); + EXPECT_EQ(msg.GetType(), CMessage::Type::Topic); msg.SetTopic("test"); - EXPECT_EQ("test", msg.GetTopic()); - EXPECT_EQ(":nick TOPIC #chan :test", msg.ToString()); + EXPECT_EQ(msg.GetTopic(), "test"); + EXPECT_EQ(msg.ToString(), ":nick TOPIC #chan :test"); } TEST(MessageTest, Parse) { @@ -476,7 +476,7 @@ TEST(MessageTest, Parse) { // #1037 msg.Parse(":irc.znc.in PRIVMSG ::)"); - EXPECT_EQ(":)", msg.GetParam(0)); + EXPECT_EQ(msg.GetParam(0), ":)"); } // The test data for MessageTest.Parse originates from @@ -511,13 +511,13 @@ TEST(MessageTest, ParseWithTags) { "COMMAND param1 param2 :param3 param3"; CMessage msg(line); - EXPECT_EQ(line, msg.ToString()); + EXPECT_EQ(msg.ToString(), line); EXPECT_THAT(msg.GetTags(), ContainerEq(MCString{{"tag1", "value1"}, {"tag2", ""}, {"vendor1/tag3", "value2"}, {"vendor2/tag4", ""}})); - EXPECT_EQ("irc.example.com", msg.GetNick().GetNick()); - EXPECT_EQ("COMMAND", msg.GetCommand()); + EXPECT_EQ(msg.GetNick().GetNick(), "irc.example.com"); + EXPECT_EQ(msg.GetCommand(), "COMMAND"); EXPECT_THAT(msg.GetParams(), ContainerEq(VCString{"param1", "param2", "param3 param3"})); } @@ -528,10 +528,10 @@ TEST(MessageTest, ParseWithoutTags) { ":irc.example.com COMMAND param1 param2 :param3 param3"; CMessage msg(line); - EXPECT_EQ(line, msg.ToString()); - EXPECT_EQ(MCString(), msg.GetTags()); - EXPECT_EQ("irc.example.com", msg.GetNick().GetNick()); - EXPECT_EQ("COMMAND", msg.GetCommand()); + EXPECT_EQ(msg.ToString(), line); + EXPECT_EQ(msg.GetTags(), MCString()); + EXPECT_EQ(msg.GetNick().GetNick(), "irc.example.com"); + EXPECT_EQ(msg.GetCommand(), "COMMAND"); EXPECT_THAT(msg.GetParams(), ContainerEq(VCString{"param1", "param2", "param3 param3"})); } @@ -543,13 +543,13 @@ TEST(MessageTest, ParseWithoutSource) { "param2 :param3 param3"; CMessage msg(line); - EXPECT_EQ(line, msg.ToString()); + EXPECT_EQ(msg.ToString(), line); EXPECT_THAT(msg.GetTags(), ContainerEq(MCString{{"tag1", "value1"}, {"tag2", ""}, {"vendor1/tag3", "value2"}, {"vendor2/tag4", ""}})); - EXPECT_EQ("", msg.GetNick().GetNick()); - EXPECT_EQ("COMMAND", msg.GetCommand()); + EXPECT_EQ(msg.GetNick().GetNick(), ""); + EXPECT_EQ(msg.GetCommand(), "COMMAND"); EXPECT_THAT(msg.GetParams(), ContainerEq(VCString{"param1", "param2", "param3 param3"})); } @@ -559,9 +559,9 @@ TEST(MessageTest, ParseWithoutSourceAndTags) { const CString line = "COMMAND"; CMessage msg(line); - EXPECT_EQ(line, msg.ToString()); - EXPECT_EQ(MCString(), msg.GetTags()); - EXPECT_EQ("", msg.GetNick().GetNick()); - EXPECT_EQ("COMMAND", msg.GetCommand()); - EXPECT_EQ(VCString(), msg.GetParams()); + EXPECT_EQ(msg.ToString(), line); + EXPECT_EQ(msg.GetTags(), MCString()); + EXPECT_EQ(msg.GetNick().GetNick(), ""); + EXPECT_EQ(msg.GetCommand(), "COMMAND"); + EXPECT_EQ(msg.GetParams(), VCString()); } diff --git a/test/ModulesTest.cpp b/test/ModulesTest.cpp index b0f3ce45..6c1e4f09 100644 --- a/test/ModulesTest.cpp +++ b/test/ModulesTest.cpp @@ -254,196 +254,196 @@ TEST_F(ModulesTest, Hooks) { CCTCPMessage UserCTCPReply; LegacyMod.eAction = CModule::HALT; Modules.OnUserCTCPReplyMessage(UserCTCPReply); - EXPECT_EQ("#legacy", UserCTCPReply.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserCTCPReply", UserCTCPReply.GetText()); + EXPECT_EQ(UserCTCPReply.GetTarget(), "#legacy"); + EXPECT_EQ(UserCTCPReply.GetText(), "CLegacyModule::OnUserCTCPReply"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserCTCPReplyMessage(UserCTCPReply); - EXPECT_EQ("#target", UserCTCPReply.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserCTCPReplyMessage", - UserCTCPReply.GetText()); + EXPECT_EQ(UserCTCPReply.GetTarget(), "#target"); + EXPECT_EQ(UserCTCPReply.GetText(), + "CMessageModule::OnUserCTCPReplyMessage"); CCTCPMessage UserCTCPMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserCTCPMessage(UserCTCPMsg); - EXPECT_EQ("#legacy", UserCTCPMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserCTCP", UserCTCPMsg.GetText()); + EXPECT_EQ(UserCTCPMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserCTCPMsg.GetText(), "CLegacyModule::OnUserCTCP"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserCTCPMessage(UserCTCPMsg); - EXPECT_EQ("#target", UserCTCPMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserCTCPMessage", UserCTCPMsg.GetText()); + EXPECT_EQ(UserCTCPMsg.GetTarget(), "#target"); + EXPECT_EQ(UserCTCPMsg.GetText(), "CMessageModule::OnUserCTCPMessage"); CActionMessage UserActionMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserActionMessage(UserActionMsg); - EXPECT_EQ("#legacy", UserActionMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserAction", UserActionMsg.GetText()); + EXPECT_EQ(UserActionMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserActionMsg.GetText(), "CLegacyModule::OnUserAction"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserActionMessage(UserActionMsg); - EXPECT_EQ("#target", UserActionMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserActionMessage", UserActionMsg.GetText()); + EXPECT_EQ(UserActionMsg.GetTarget(), "#target"); + EXPECT_EQ(UserActionMsg.GetText(), "CMessageModule::OnUserActionMessage"); CTextMessage UserTextMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserTextMessage(UserTextMsg); - EXPECT_EQ("#legacy", UserTextMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserMsg", UserTextMsg.GetText()); + EXPECT_EQ(UserTextMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserTextMsg.GetText(), "CLegacyModule::OnUserMsg"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserTextMessage(UserTextMsg); - EXPECT_EQ("#target", UserTextMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserTextMessage", UserTextMsg.GetText()); + EXPECT_EQ(UserTextMsg.GetTarget(), "#target"); + EXPECT_EQ(UserTextMsg.GetText(), "CMessageModule::OnUserTextMessage"); CNoticeMessage UserNoticeMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserNoticeMessage(UserNoticeMsg); - EXPECT_EQ("#legacy", UserNoticeMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserNotice", UserNoticeMsg.GetText()); + EXPECT_EQ(UserNoticeMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserNoticeMsg.GetText(), "CLegacyModule::OnUserNotice"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserNoticeMessage(UserNoticeMsg); - EXPECT_EQ("#target", UserNoticeMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserNoticeMessage", UserNoticeMsg.GetText()); + EXPECT_EQ(UserNoticeMsg.GetTarget(), "#target"); + EXPECT_EQ(UserNoticeMsg.GetText(), "CMessageModule::OnUserNoticeMessage"); CJoinMessage UserJoinMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserJoinMessage(UserJoinMsg); - EXPECT_EQ("#legacy", UserJoinMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserJoin", UserJoinMsg.GetKey()); + EXPECT_EQ(UserJoinMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserJoinMsg.GetKey(), "CLegacyModule::OnUserJoin"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserJoinMessage(UserJoinMsg); - EXPECT_EQ("#target", UserJoinMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserJoinMessage", UserJoinMsg.GetKey()); + EXPECT_EQ(UserJoinMsg.GetTarget(), "#target"); + EXPECT_EQ(UserJoinMsg.GetKey(), "CMessageModule::OnUserJoinMessage"); CPartMessage UserPartMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserPartMessage(UserPartMsg); - EXPECT_EQ("#legacy", UserPartMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserPart", UserPartMsg.GetReason()); + EXPECT_EQ(UserPartMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserPartMsg.GetReason(), "CLegacyModule::OnUserPart"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserPartMessage(UserPartMsg); - EXPECT_EQ("#target", UserPartMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserPartMessage", UserPartMsg.GetReason()); + EXPECT_EQ(UserPartMsg.GetTarget(), "#target"); + EXPECT_EQ(UserPartMsg.GetReason(), "CMessageModule::OnUserPartMessage"); CTopicMessage UserTopicMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserTopicMessage(UserTopicMsg); - EXPECT_EQ("#legacy", UserTopicMsg.GetTarget()); - EXPECT_EQ("CLegacyModule::OnUserTopic", UserTopicMsg.GetTopic()); + EXPECT_EQ(UserTopicMsg.GetTarget(), "#legacy"); + EXPECT_EQ(UserTopicMsg.GetTopic(), "CLegacyModule::OnUserTopic"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserTopicMessage(UserTopicMsg); - EXPECT_EQ("#target", UserTopicMsg.GetTarget()); - EXPECT_EQ("CMessageModule::OnUserTopicMessage", UserTopicMsg.GetTopic()); + EXPECT_EQ(UserTopicMsg.GetTarget(), "#target"); + EXPECT_EQ(UserTopicMsg.GetTopic(), "CMessageModule::OnUserTopicMessage"); CQuitMessage UserQuitMsg; LegacyMod.eAction = CModule::HALT; Modules.OnUserQuitMessage(UserQuitMsg); - EXPECT_EQ("CLegacyModule::OnUserQuit", UserQuitMsg.GetReason()); + EXPECT_EQ(UserQuitMsg.GetReason(), "CLegacyModule::OnUserQuit"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnUserQuitMessage(UserQuitMsg); - EXPECT_EQ("CMessageModule::OnUserQuitMessage", UserQuitMsg.GetReason()); + EXPECT_EQ(UserQuitMsg.GetReason(), "CMessageModule::OnUserQuitMessage"); CCTCPMessage CTCPReply; LegacyMod.eAction = CModule::HALT; Modules.OnCTCPReplyMessage(CTCPReply); - EXPECT_EQ("legacy", CTCPReply.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnCTCPReply", CTCPReply.GetText()); + EXPECT_EQ(CTCPReply.GetNick().GetNick(), "legacy"); + EXPECT_EQ(CTCPReply.GetText(), "CLegacyModule::OnCTCPReply"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnCTCPReplyMessage(CTCPReply); - EXPECT_EQ("nick", CTCPReply.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnCTCPReplyMessage", CTCPReply.GetText()); + EXPECT_EQ(CTCPReply.GetNick().GetNick(), "nick"); + EXPECT_EQ(CTCPReply.GetText(), "CMessageModule::OnCTCPReplyMessage"); CCTCPMessage PrivCTCP; LegacyMod.eAction = CModule::HALT; Modules.OnPrivCTCPMessage(PrivCTCP); - EXPECT_EQ("legacy", PrivCTCP.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnPrivCTCP", PrivCTCP.GetText()); + EXPECT_EQ(PrivCTCP.GetNick().GetNick(), "legacy"); + EXPECT_EQ(PrivCTCP.GetText(), "CLegacyModule::OnPrivCTCP"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnPrivCTCPMessage(PrivCTCP); - EXPECT_EQ("nick", PrivCTCP.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnPrivCTCPMessage", PrivCTCP.GetText()); + EXPECT_EQ(PrivCTCP.GetNick().GetNick(), "nick"); + EXPECT_EQ(PrivCTCP.GetText(), "CMessageModule::OnPrivCTCPMessage"); CCTCPMessage ChanCTCP; LegacyMod.eAction = CModule::HALT; Modules.OnChanCTCPMessage(ChanCTCP); - EXPECT_EQ("legacy", ChanCTCP.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnChanCTCP", ChanCTCP.GetText()); + EXPECT_EQ(ChanCTCP.GetNick().GetNick(), "legacy"); + EXPECT_EQ(ChanCTCP.GetText(), "CLegacyModule::OnChanCTCP"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnChanCTCPMessage(ChanCTCP); - EXPECT_EQ("nick", ChanCTCP.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnChanCTCPMessage", ChanCTCP.GetText()); + EXPECT_EQ(ChanCTCP.GetNick().GetNick(), "nick"); + EXPECT_EQ(ChanCTCP.GetText(), "CMessageModule::OnChanCTCPMessage"); CActionMessage PrivAction; LegacyMod.eAction = CModule::HALT; Modules.OnPrivActionMessage(PrivAction); - EXPECT_EQ("legacy", PrivAction.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnPrivAction", PrivAction.GetText()); + EXPECT_EQ(PrivAction.GetNick().GetNick(), "legacy"); + EXPECT_EQ(PrivAction.GetText(), "CLegacyModule::OnPrivAction"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnPrivActionMessage(PrivAction); - EXPECT_EQ("nick", PrivAction.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnPrivActionMessage", PrivAction.GetText()); + EXPECT_EQ(PrivAction.GetNick().GetNick(), "nick"); + EXPECT_EQ(PrivAction.GetText(), "CMessageModule::OnPrivActionMessage"); CActionMessage ChanAction; LegacyMod.eAction = CModule::HALT; Modules.OnChanActionMessage(ChanAction); - EXPECT_EQ("legacy", ChanAction.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnChanAction", ChanAction.GetText()); + EXPECT_EQ(ChanAction.GetNick().GetNick(), "legacy"); + EXPECT_EQ(ChanAction.GetText(), "CLegacyModule::OnChanAction"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnChanActionMessage(ChanAction); - EXPECT_EQ("nick", ChanAction.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnChanActionMessage", ChanAction.GetText()); + EXPECT_EQ(ChanAction.GetNick().GetNick(), "nick"); + EXPECT_EQ(ChanAction.GetText(), "CMessageModule::OnChanActionMessage"); CTextMessage PrivMsg; LegacyMod.eAction = CModule::HALT; Modules.OnPrivTextMessage(PrivMsg); - EXPECT_EQ("legacy", PrivMsg.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnPrivMsg", PrivMsg.GetText()); + EXPECT_EQ(PrivMsg.GetNick().GetNick(), "legacy"); + EXPECT_EQ(PrivMsg.GetText(), "CLegacyModule::OnPrivMsg"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnPrivTextMessage(PrivMsg); - EXPECT_EQ("nick", PrivMsg.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnPrivTextMessage", PrivMsg.GetText()); + EXPECT_EQ(PrivMsg.GetNick().GetNick(), "nick"); + EXPECT_EQ(PrivMsg.GetText(), "CMessageModule::OnPrivTextMessage"); CTextMessage ChanMsg; LegacyMod.eAction = CModule::HALT; Modules.OnChanTextMessage(ChanMsg); - EXPECT_EQ("legacy", ChanMsg.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnChanMsg", ChanMsg.GetText()); + EXPECT_EQ(ChanMsg.GetNick().GetNick(), "legacy"); + EXPECT_EQ(ChanMsg.GetText(), "CLegacyModule::OnChanMsg"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnChanTextMessage(ChanMsg); - EXPECT_EQ("nick", ChanMsg.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnChanTextMessage", ChanMsg.GetText()); + EXPECT_EQ(ChanMsg.GetNick().GetNick(), "nick"); + EXPECT_EQ(ChanMsg.GetText(), "CMessageModule::OnChanTextMessage"); CNoticeMessage PrivNotice; LegacyMod.eAction = CModule::HALT; Modules.OnPrivNoticeMessage(PrivNotice); - EXPECT_EQ("legacy", PrivNotice.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnPrivNotice", PrivNotice.GetText()); + EXPECT_EQ(PrivNotice.GetNick().GetNick(), "legacy"); + EXPECT_EQ(PrivNotice.GetText(), "CLegacyModule::OnPrivNotice"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnPrivNoticeMessage(PrivNotice); - EXPECT_EQ("nick", PrivNotice.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnPrivNoticeMessage", PrivNotice.GetText()); + EXPECT_EQ(PrivNotice.GetNick().GetNick(), "nick"); + EXPECT_EQ(PrivNotice.GetText(), "CMessageModule::OnPrivNoticeMessage"); CNoticeMessage ChanNotice; LegacyMod.eAction = CModule::HALT; Modules.OnChanNoticeMessage(ChanNotice); - EXPECT_EQ("legacy", ChanNotice.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnChanNotice", ChanNotice.GetText()); + EXPECT_EQ(ChanNotice.GetNick().GetNick(), "legacy"); + EXPECT_EQ(ChanNotice.GetText(), "CLegacyModule::OnChanNotice"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnChanNoticeMessage(ChanNotice); - EXPECT_EQ("nick", ChanNotice.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnChanNoticeMessage", ChanNotice.GetText()); + EXPECT_EQ(ChanNotice.GetNick().GetNick(), "nick"); + EXPECT_EQ(ChanNotice.GetText(), "CMessageModule::OnChanNoticeMessage"); CTopicMessage TopicMsg; LegacyMod.eAction = CModule::HALT; Modules.OnTopicMessage(TopicMsg); - EXPECT_EQ("legacy", TopicMsg.GetNick().GetNick()); - EXPECT_EQ("CLegacyModule::OnTopic", TopicMsg.GetTopic()); + EXPECT_EQ(TopicMsg.GetNick().GetNick(), "legacy"); + EXPECT_EQ(TopicMsg.GetTopic(), "CLegacyModule::OnTopic"); LegacyMod.eAction = CModule::CONTINUE; Modules.OnTopicMessage(TopicMsg); - EXPECT_EQ("nick", TopicMsg.GetNick().GetNick()); - EXPECT_EQ("CMessageModule::OnTopicMessage", TopicMsg.GetTopic()); + EXPECT_EQ(TopicMsg.GetNick().GetNick(), "nick"); + EXPECT_EQ(TopicMsg.GetTopic(), "CMessageModule::OnTopicMessage"); CNumericMessage NumericMsg; Modules.OnNumericMessage(NumericMsg); - EXPECT_EQ("nick", TopicMsg.GetNick().GetNick()); - EXPECT_EQ(123u, NumericMsg.GetCode()); + EXPECT_EQ(TopicMsg.GetNick().GetNick(), "nick"); + EXPECT_EQ(NumericMsg.GetCode(), 123u); Modules.clear(); } diff --git a/test/NetworkTest.cpp b/test/NetworkTest.cpp index ec5a6739..f20a58d3 100644 --- a/test/NetworkTest.cpp +++ b/test/NetworkTest.cpp @@ -54,10 +54,10 @@ TEST_F(NetworkTest, FindChans) { EXPECT_TRUE(network.AddChan("#Bar", false)); EXPECT_TRUE(network.AddChan("#BAZ", false)); - EXPECT_EQ(1u, network.FindChans("#f*").size()); - EXPECT_EQ(2u, network.FindChans("#b*").size()); - EXPECT_EQ(2u, network.FindChans("#?A*").size()); - EXPECT_EQ(1u, network.FindChans("*z").size()); + EXPECT_EQ(network.FindChans("#f*").size(), 1u); + EXPECT_EQ(network.FindChans("#b*").size(), 2u); + EXPECT_EQ(network.FindChans("#?A*").size(), 2u); + EXPECT_EQ(network.FindChans("*z").size(), 1u); } TEST_F(NetworkTest, FindQuery) { @@ -89,8 +89,8 @@ TEST_F(NetworkTest, FindQueries) { EXPECT_TRUE(network.AddQuery("Bar")); EXPECT_TRUE(network.AddQuery("BAZ")); - EXPECT_EQ(1u, network.FindQueries("f*").size()); - EXPECT_EQ(2u, network.FindQueries("b*").size()); - EXPECT_EQ(2u, network.FindQueries("?A*").size()); - EXPECT_EQ(1u, network.FindQueries("*z").size()); + EXPECT_EQ(network.FindQueries("f*").size(), 1u); + EXPECT_EQ(network.FindQueries("b*").size(), 2u); + EXPECT_EQ(network.FindQueries("?A*").size(), 2u); + EXPECT_EQ(network.FindQueries("*z").size(), 1u); } diff --git a/test/NickTest.cpp b/test/NickTest.cpp index 84f05184..97f8ed52 100644 --- a/test/NickTest.cpp +++ b/test/NickTest.cpp @@ -19,18 +19,18 @@ TEST(NickTest, Parse) { CNick Nick1("nick!~ident@host"); - EXPECT_EQ("nick", Nick1.GetNick()); - EXPECT_EQ("~ident", Nick1.GetIdent()); - EXPECT_EQ("host", Nick1.GetHost()); - EXPECT_EQ("nick!~ident@host", Nick1.GetNickMask()); - EXPECT_EQ("nick!~ident@host", Nick1.GetHostMask()); + EXPECT_EQ(Nick1.GetNick(), "nick"); + EXPECT_EQ(Nick1.GetIdent(), "~ident"); + EXPECT_EQ(Nick1.GetHost(), "host"); + EXPECT_EQ(Nick1.GetNickMask(), "nick!~ident@host"); + EXPECT_EQ(Nick1.GetHostMask(), "nick!~ident@host"); EXPECT_TRUE(Nick1.NickEquals("nick")); CNick Nick2(":nick!~ident@host"); - EXPECT_EQ("nick", Nick2.GetNick()); - EXPECT_EQ("~ident", Nick2.GetIdent()); - EXPECT_EQ("host", Nick2.GetHost()); - EXPECT_EQ("nick!~ident@host", Nick2.GetNickMask()); - EXPECT_EQ("nick!~ident@host", Nick2.GetHostMask()); + EXPECT_EQ(Nick2.GetNick(), "nick"); + EXPECT_EQ(Nick2.GetIdent(), "~ident"); + EXPECT_EQ(Nick2.GetHost(), "host"); + EXPECT_EQ(Nick2.GetNickMask(), "nick!~ident@host"); + EXPECT_EQ(Nick2.GetHostMask(), "nick!~ident@host"); EXPECT_TRUE(Nick2.NickEquals("nick")); } diff --git a/test/QueryTest.cpp b/test/QueryTest.cpp index b48b127f..9888b2a7 100644 --- a/test/QueryTest.cpp +++ b/test/QueryTest.cpp @@ -34,7 +34,7 @@ TEST_F(QueryTest, Name) { CIRCNetwork network(&user, "network"); CQuery query("query", &network); - EXPECT_EQ("query", query.GetName()); + EXPECT_EQ(query.GetName(), "query"); } TEST_F(QueryTest, AddClearBuffer) { @@ -44,9 +44,9 @@ TEST_F(QueryTest, AddClearBuffer) { CQuery query("query", &network); EXPECT_TRUE(query.GetBuffer().IsEmpty()); query.AddBuffer("foo"); - EXPECT_EQ(1u, query.GetBuffer().Size()); + EXPECT_EQ(query.GetBuffer().Size(), 1u); query.AddBuffer("bar"); - EXPECT_EQ(2u, query.GetBuffer().Size()); + EXPECT_EQ(query.GetBuffer().Size(), 2u); query.ClearBuffer(); EXPECT_TRUE(query.GetBuffer().IsEmpty()); } @@ -56,16 +56,16 @@ TEST_F(QueryTest, BufferSize) { CIRCNetwork network(&user, "network"); CQuery query("query", &network); - EXPECT_EQ(50u, user.GetQueryBufferSize()); - EXPECT_EQ(50u, query.GetBufferCount()); + EXPECT_EQ(user.GetQueryBufferSize(), 50u); + EXPECT_EQ(query.GetBufferCount(), 50u); - EXPECT_EQ(500u, CZNC::Get().GetMaxBufferSize()); + EXPECT_EQ(CZNC::Get().GetMaxBufferSize(), 500u); EXPECT_FALSE(query.SetBufferCount(1000, false)); - EXPECT_EQ(50u, query.GetBufferCount()); + EXPECT_EQ(query.GetBufferCount(), 50u); EXPECT_TRUE(query.SetBufferCount(500, false)); - EXPECT_EQ(500u, query.GetBufferCount()); + EXPECT_EQ(query.GetBufferCount(), 500u); EXPECT_TRUE(query.SetBufferCount(1000, true)); - EXPECT_EQ(1000u, query.GetBufferCount()); + EXPECT_EQ(query.GetBufferCount(), 1000u); } TEST_F(QueryTest, SendBuffer) { diff --git a/test/StringTest.cpp b/test/StringTest.cpp index 6a38a636..a675a3f7 100644 --- a/test/StringTest.cpp +++ b/test/StringTest.cpp @@ -33,9 +33,9 @@ class EscapeTest : public ::testing::Test { // Encode, then decode again and check we still got the same string out = in.Escape_n(CString::EASCII, format); - EXPECT_EQ(expectedOut, out); + EXPECT_EQ(out, expectedOut); out = out.Escape_n(format, CString::EASCII); - EXPECT_EQ(in, out); + EXPECT_EQ(out, in); } void testString(const CString& in, const CString& url, const CString& html, @@ -70,15 +70,15 @@ TEST(StringTest, Bool) { TEST(StringTest, Cmp) { CString s = "Bbb"; - EXPECT_EQ(CString("Bbb"), s); + EXPECT_EQ(s, CString("Bbb")); EXPECT_LT(CString("Aaa"), s); EXPECT_GT(CString("Ccc"), s); - EXPECT_EQ(0, s.StrCmp("Bbb")); + EXPECT_EQ(s.StrCmp("Bbb"), 0); EXPECT_GT(0, s.StrCmp("bbb")); EXPECT_LT(0, s.StrCmp("Aaa")); EXPECT_GT(0, s.StrCmp("Ccc")); - EXPECT_EQ(0, s.CaseCmp("Bbb")); - EXPECT_EQ(0, s.CaseCmp("bbb")); + EXPECT_EQ(s.CaseCmp("Bbb"), 0); + EXPECT_EQ(s.CaseCmp("bbb"), 0); EXPECT_LT(0, s.CaseCmp("Aaa")); EXPECT_GT(0, s.CaseCmp("Ccc")); @@ -123,43 +123,43 @@ TEST(StringTest, Wild) { TEST(StringTest, Case) { CString x = CS("xx"); CString X = CS("XX"); - EXPECT_EQ(X, x.AsUpper()); - EXPECT_EQ(x, X.AsLower()); + EXPECT_EQ(x.AsUpper(), X); + EXPECT_EQ(X.AsLower(), x); } TEST(StringTest, Replace) { - EXPECT_EQ("(b()b)", CString("(a()a)").Replace_n("a", "b")); - EXPECT_EQ("(a()b)", CString("(a()a)").Replace_n("a", "b", "(", ")")); - EXPECT_EQ("a(b)", CString("(a()a)").Replace_n("a", "b", "(", ")", true)); + EXPECT_EQ(CString("(a()a)").Replace_n("a", "b"), "(b()b)"); + EXPECT_EQ(CString("(a()a)").Replace_n("a", "b", "(", ")"), "(a()b)"); + EXPECT_EQ(CString("(a()a)").Replace_n("a", "b", "(", ")", true), "a(b)"); } TEST(StringTest, Misc) { - EXPECT_EQ("Hello,...", CString("Hello, I'm Bob").Ellipsize(9)); - EXPECT_EQ("Hello, I'm Bob", CString("Hello, I'm Bob").Ellipsize(90)); - EXPECT_EQ("..", CString("Hello, I'm Bob").Ellipsize(2)); + EXPECT_EQ(CString("Hello, I'm Bob").Ellipsize(9), "Hello,..."); + EXPECT_EQ(CString("Hello, I'm Bob").Ellipsize(90), "Hello, I'm Bob"); + EXPECT_EQ(CString("Hello, I'm Bob").Ellipsize(2), ".."); - EXPECT_EQ("Xy", CS("Xyz").Left(2)); - EXPECT_EQ("Xyz", CS("Xyz").Left(20)); + EXPECT_EQ(CS("Xyz").Left(2), "Xy"); + EXPECT_EQ(CS("Xyz").Left(20), "Xyz"); - EXPECT_EQ("yz", CS("Xyz").Right(2)); - EXPECT_EQ("Xyz", CS("Xyz").Right(20)); + EXPECT_EQ(CS("Xyz").Right(2), "yz"); + EXPECT_EQ(CS("Xyz").Right(20), "Xyz"); } TEST(StringTest, Split) { - EXPECT_EQ("a", CS("a b c").Token(0)); - EXPECT_EQ("b", CS("a b c").Token(1)); - EXPECT_EQ("", CS("a b c").Token(100)); - EXPECT_EQ("b c", CS("a b c").Token(1, true)); - EXPECT_EQ("c", CS("a c").Token(1)); - EXPECT_EQ("", CS("a c").Token(1, false, " ", true)); - EXPECT_EQ("c", CS("a c").Token(1, false, " ")); - EXPECT_EQ(" c", CS("a c").Token(1, false, " ")); - EXPECT_EQ("c", CS("a c").Token(1, false, " ")); - EXPECT_EQ("b c", CS("a (b c) d").Token(1, false, " ", false, "(", ")")); - EXPECT_EQ("(b c)", - CS("a (b c) d").Token(1, false, " ", false, "(", ")", false)); - EXPECT_EQ("d", - CS("a (b c) d").Token(2, false, " ", false, "(", ")", false)); + EXPECT_EQ(CS("a b c").Token(0), "a"); + EXPECT_EQ(CS("a b c").Token(1), "b"); + EXPECT_EQ(CS("a b c").Token(100), ""); + EXPECT_EQ(CS("a b c").Token(1, true), "b c"); + EXPECT_EQ(CS("a c").Token(1), "c"); + EXPECT_EQ(CS("a c").Token(1, false, " ", true), ""); + EXPECT_EQ(CS("a c").Token(1, false, " "), "c"); + EXPECT_EQ(CS("a c").Token(1, false, " "), " c"); + EXPECT_EQ(CS("a c").Token(1, false, " "), "c"); + EXPECT_EQ(CS("a (b c) d").Token(1, false, " ", false, "(", ")"), "b c"); + EXPECT_EQ(CS("a (b c) d").Token(1, false, " ", false, "(", ")", false), + "(b c)"); + EXPECT_EQ(CS("a (b c) d").Token(2, false, " ", false, "(", ")", false), + "d"); VCString vexpected; VCString vresult; @@ -168,7 +168,7 @@ TEST(StringTest, Split) { vexpected.push_back("b"); vexpected.push_back("c"); CS("a b c").Split(" ", vresult); - EXPECT_EQ(vexpected, vresult); + EXPECT_EQ(vresult, vexpected); MCString mexpected = {{"a", "b"}, {"c", "d"}}; MCString mresult; @@ -179,19 +179,19 @@ TEST(StringTest, Split) { TEST(StringTest, NamedFormat) { MCString m = {{"a", "b"}}; - EXPECT_EQ("{xbyb", CString::NamedFormat(CS("\\{x{a}y{a}"), m)); + EXPECT_EQ(CString::NamedFormat(CS("\\{x{a}y{a}"), m), "{xbyb"); } TEST(StringTest, Hash) { - EXPECT_EQ("d41d8cd98f00b204e9800998ecf8427e", CS("").MD5()); - EXPECT_EQ("0cc175b9c0f1b6a831c399e269772661", CS("a").MD5()); + EXPECT_EQ(CS("").MD5(), "d41d8cd98f00b204e9800998ecf8427e"); + EXPECT_EQ(CS("a").MD5(), "0cc175b9c0f1b6a831c399e269772661"); EXPECT_EQ( - "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", - CS("").SHA256()); + CS("").SHA256(), + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); EXPECT_EQ( - "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb", - CS("a").SHA256()); + CS("a").SHA256(), + "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"); } TEST(StringTest, Equals) { @@ -203,17 +203,17 @@ TEST(StringTest, Equals) { } TEST(StringTest, Find) { - EXPECT_EQ(0u, CString("Hello, I'm Bob").Find("Hello")); + EXPECT_EQ(CString("Hello, I'm Bob").Find("Hello"), 0u); EXPECT_EQ( - 0u, CString("Hello, I'm Bob").Find("Hello", CString::CaseInsensitive)); - EXPECT_EQ(0u, - CString("Hello, I'm Bob").Find("Hello", CString::CaseSensitive)); + CString("Hello, I'm Bob").Find("Hello", CString::CaseInsensitive), 0u); + EXPECT_EQ(CString("Hello, I'm Bob").Find("Hello", CString::CaseSensitive), + 0u); - EXPECT_EQ(7u, CString("Hello, I'm Bob").Find("i'm")); - EXPECT_EQ(7u, - CString("Hello, I'm Bob").Find("i'm", CString::CaseInsensitive)); - EXPECT_EQ(CString::npos, - CString("Hello, I'm Bob").Find("i'm", CString::CaseSensitive)); + EXPECT_EQ(CString("Hello, I'm Bob").Find("i'm"), 7u); + EXPECT_EQ(CString("Hello, I'm Bob").Find("i'm", CString::CaseInsensitive), + 7u); + EXPECT_EQ(CString("Hello, I'm Bob").Find("i'm", CString::CaseSensitive), + CString::npos); } TEST(StringTest, StartsWith) { diff --git a/test/ThreadTest.cpp b/test/ThreadTest.cpp index 86f33ba5..2d0705f3 100644 --- a/test/ThreadTest.cpp +++ b/test/ThreadTest.cpp @@ -174,8 +174,8 @@ TEST(Thread, CancelJobWhenDone) { fd_set fds; FD_ZERO(&fds); FD_SET(CThreadPool::Get().getReadFD(), &fds); - EXPECT_EQ(1, select(1 + CThreadPool::Get().getReadFD(), &fds, nullptr, - nullptr, nullptr)); + EXPECT_EQ(select(1 + CThreadPool::Get().getReadFD(), &fds, nullptr, + nullptr, nullptr), 1); // And only cancel it afterwards CThreadPool::Get().cancelJob(pJob); diff --git a/test/UserTest.cpp b/test/UserTest.cpp index 6691ce16..332dbb9a 100644 --- a/test/UserTest.cpp +++ b/test/UserTest.cpp @@ -115,7 +115,7 @@ TEST_F(UserTest, IsHostAllowed) { for (const hostTest& h : aHostTests) { CUser user("user"); user.AddAllowedHost(h.sMask); - EXPECT_EQ(h.bExpectedResult, user.IsHostAllowed(h.sIP)) + EXPECT_EQ(user.IsHostAllowed(h.sIP), h.bExpectedResult) << "Allow-host is " << h.sMask; } } diff --git a/test/UtilsTest.cpp b/test/UtilsTest.cpp index 5c5d7f16..e9c01075 100644 --- a/test/UtilsTest.cpp +++ b/test/UtilsTest.cpp @@ -19,38 +19,38 @@ #include TEST(IRC32, GetMessageTags) { - EXPECT_EQ(MCString(), CUtils::GetMessageTags("")); - EXPECT_EQ(MCString(), CUtils::GetMessageTags( - ":nick!ident@host PRIVMSG #chan :hello world")); + EXPECT_EQ(CUtils::GetMessageTags(""), MCString()); + EXPECT_EQ(CUtils::GetMessageTags( + ":nick!ident@host PRIVMSG #chan :hello world"), MCString()); MCString exp = {{"a", "b"}}; - EXPECT_EQ(exp, CUtils::GetMessageTags("@a=b")); - EXPECT_EQ(exp, CUtils::GetMessageTags( - "@a=b :nick!ident@host PRIVMSG #chan :hello world")); - EXPECT_EQ(exp, CUtils::GetMessageTags("@a=b :rest")); + EXPECT_EQ(CUtils::GetMessageTags("@a=b"), exp); + EXPECT_EQ(CUtils::GetMessageTags( + "@a=b :nick!ident@host PRIVMSG #chan :hello world"), exp); + EXPECT_EQ(CUtils::GetMessageTags("@a=b :rest"), exp); exp.clear(); exp = {{"ab", "cdef"}, {"znc.in/gh-ij", "klmn,op"}}; - EXPECT_EQ(exp, - CUtils::GetMessageTags("@ab=cdef;znc.in/gh-ij=klmn,op :rest")); + EXPECT_EQ(CUtils::GetMessageTags("@ab=cdef;znc.in/gh-ij=klmn,op :rest"), + exp); exp = {{"a", "==b=="}}; - EXPECT_EQ(exp, CUtils::GetMessageTags("@a===b== :rest")); + EXPECT_EQ(CUtils::GetMessageTags("@a===b== :rest"), exp); exp.clear(); exp = {{"a", ""}, {"b", "c"}, {"d", ""}}; - EXPECT_EQ(exp, CUtils::GetMessageTags("@a;b=c;d :rest")); + EXPECT_EQ(CUtils::GetMessageTags("@a;b=c;d :rest"), exp); exp = {{"semi-colon", ";"}, {"space", " "}, {"NUL", {'\0'}}, {"backslash", "\\"}, {"CR", {'\r'}}, {"LF", {'\n'}}}; EXPECT_EQ( - exp, CUtils::GetMessageTags( - R"(@semi-colon=\:;space=\s;NUL=\0;backslash=\\;CR=\r;LF=\n :rest)")); + R"(@semi-colon=\:;space=\s;NUL=\0;backslash=\\;CR=\r;LF=\n :rest)"), + exp); exp.clear(); exp = {{"a", "; \\\r\n"}}; - EXPECT_EQ(exp, CUtils::GetMessageTags(R"(@a=\:\s\\\r\n :rest)")); + EXPECT_EQ(CUtils::GetMessageTags(R"(@a=\:\s\\\r\n :rest)"), exp); exp.clear(); } @@ -59,30 +59,30 @@ TEST(IRC32, SetMessageTags) { sLine = ":rest"; CUtils::SetMessageTags(sLine, MCString()); - EXPECT_EQ(":rest", sLine); + EXPECT_EQ(sLine, ":rest"); MCString tags = {{"a", "b"}}; CUtils::SetMessageTags(sLine, tags); - EXPECT_EQ("@a=b :rest", sLine); + EXPECT_EQ(sLine, "@a=b :rest"); tags = {{"a", "b"}, {"c", "d"}}; CUtils::SetMessageTags(sLine, tags); - EXPECT_EQ("@a=b;c=d :rest", sLine); + EXPECT_EQ(sLine, "@a=b;c=d :rest"); tags = {{"a", "b"}, {"c", "d"}, {"e", ""}}; CUtils::SetMessageTags(sLine, tags); - EXPECT_EQ("@a=b;c=d;e :rest", sLine); + EXPECT_EQ(sLine, "@a=b;c=d;e :rest"); tags = {{"semi-colon", ";"}, {"space", " "}, {"NUL", {'\0'}}, {"backslash", "\\"}, {"CR", {'\r'}}, {"LF", {'\n'}}}; CUtils::SetMessageTags(sLine, tags); EXPECT_EQ( - R"(@CR=\r;LF=\n;NUL=\0;backslash=\\;semi-colon=\:;space=\s :rest)", - sLine); + sLine, + R"(@CR=\r;LF=\n;NUL=\0;backslash=\\;semi-colon=\:;space=\s :rest)"); tags = {{"a", "; \\\r\n"}}; CUtils::SetMessageTags(sLine, tags); - EXPECT_EQ(R"(@a=\:\s\\\r\n :rest)", sLine); + EXPECT_EQ(sLine, R"(@a=\:\s\\\r\n :rest)"); } TEST(UtilsTest, ServerTime) { @@ -93,7 +93,7 @@ TEST(UtilsTest, ServerTime) { timeval tv1 = CUtils::ParseServerTime("2011-10-19T16:40:51.620Z"); CString str1 = CUtils::FormatServerTime(tv1); - EXPECT_EQ("2011-10-19T16:40:51.620Z", str1); + EXPECT_EQ(str1, "2011-10-19T16:40:51.620Z"); timeval now = CUtils::GetTime(); @@ -102,12 +102,12 @@ TEST(UtilsTest, ServerTime) { CString str2 = CUtils::FormatServerTime(now); timeval tv2 = CUtils::ParseServerTime(str2); - EXPECT_EQ(now.tv_sec, tv2.tv_sec); - EXPECT_EQ(now.tv_usec, tv2.tv_usec); + EXPECT_EQ(tv2.tv_sec, now.tv_sec); + EXPECT_EQ(tv2.tv_usec, now.tv_usec); timeval tv3 = CUtils::ParseServerTime("invalid"); CString str3 = CUtils::FormatServerTime(tv3); - EXPECT_EQ("1970-01-01T00:00:00.000Z", str3); + EXPECT_EQ(str3, "1970-01-01T00:00:00.000Z"); if (oldTZ) { setenv("TZ", oldTZ, 1); @@ -144,16 +144,16 @@ TEST(UtilsTest, FormatTime) { tv1.tv_sec = 42; tv1.tv_usec = 123456; CString str1 = CUtils::FormatTime(tv1, "%s", "UTC"); - EXPECT_EQ("42", str1); + EXPECT_EQ(str1, "42"); // Test escapes timeval tv2; tv2.tv_sec = 42; tv2.tv_usec = 123456; CString str2 = CUtils::FormatTime(tv2, "%%f", "UTC"); - EXPECT_EQ("%f", str2); + EXPECT_EQ(str2, "%f"); // Test suffix CString str3 = CUtils::FormatTime(tv2, "a%fb", "UTC"); - EXPECT_EQ("a123b", str3); + EXPECT_EQ(str3, "a123b"); }