generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-11-24 22:29:47 +01:00
Code Issues Projects Releases Wiki Activity

Poco 1.9.1 assert true (#2255)

Browse Source 
* Rename assert by assertTrue

* Update submodules

* Missing assertTrue

* Rename poco_assertTrue to poco_assert

* Rename poco_assertTrue to poco_assert
This commit is contained in:
zosrothko
2018-03-29 19:12:54 +02:00
committed by Aleksandar Fabijanic
parent 5a1bf5eb4a
commit 960ecb38f0
232 changed files with 16274 additions and 16265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
Net/testsuite/src/DNSTest.cpp
View File

@@ -39,14 +39,14 @@ void DNSTest::testHostByName()
{
HostEntry he1 = DNS::hostByName("aliastest.pocoproject.org");
// different systems report different canonical names, unfortunately.
assert (he1.name() == "dnstest.pocoproject.org" || he1.name() == "aliastest.pocoproject.org");
assertTrue (he1.name() == "dnstest.pocoproject.org" || he1.name() == "aliastest.pocoproject.org");
#if !defined(POCO_HAVE_ADDRINFO)
// getaddrinfo() does not report any aliases
assert (!he1.aliases().empty());
assert (he1.aliases()[0] == "aliastest.pocoproject.org");
assertTrue (!he1.aliases().empty());
assertTrue (he1.aliases()[0] == "aliastest.pocoproject.org");
#endif
assert (he1.addresses().size() >= 1);
assert (he1.addresses()[0].toString() == "1.2.3.4");
assertTrue (he1.addresses().size() >= 1);
assertTrue (he1.addresses()[0].toString() == "1.2.3.4");
try
{
@@ -66,10 +66,10 @@ void DNSTest::testHostByAddress()
{
IPAddress ip1("80.122.195.86");
HostEntry he1 = DNS::hostByAddress(ip1);
assert (he1.name() == "mailhost.appinf.com");
assert (he1.aliases().empty());
assert (he1.addresses().size() >= 1);
assert (he1.addresses()[0].toString() == "80.122.195.86");
assertTrue (he1.name() == "mailhost.appinf.com");
assertTrue (he1.aliases().empty());
assertTrue (he1.addresses().size() >= 1);
assertTrue (he1.addresses()[0].toString() == "80.122.195.86");
IPAddress ip2("10.0.244.253");
try
@@ -94,88 +94,88 @@ void DNSTest::testResolve()
void DNSTest::testEncodeIDN()
{
std::string idn("d\xc3\xb6m\xc3\xa4in.example"); // d"om"ain.example
assert (DNS::isIDN(idn));
assert (DNS::encodeIDN(idn) == "xn--dmin-moa0i.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--dmin-moa0i.example");
idn = ".d\xc3\xb6m\xc3\xa4in.example"; // .d"om"ain.example
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == ".xn--dmin-moa0i.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == ".xn--dmin-moa0i.example");
idn = "d\xc3\xb6m\xc3\xa4in.example."; // .d"om"ain.example.
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--dmin-moa0i.example.");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--dmin-moa0i.example.");
idn = "d\xc3\xb6m\xc3\xa4in"; // d"om"ain
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--dmin-moa0i");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--dmin-moa0i");
idn = "\xc3\xa4""aaa.example"; // "aaaa.example
assert (DNS::isIDN(idn));
assert (DNS::encodeIDN(idn) == "xn--aaa-pla.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--aaa-pla.example");
idn = "a\xc3\xa4""aa.example"; // a"aaa.example
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--aaa-qla.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--aaa-qla.example");
idn = "foo.\xc3\xa2""bcd\xc3\xa9""f.example"; // foo.^abcd'ef.example
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "foo.xn--bcdf-9na9b.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "foo.xn--bcdf-9na9b.example");
idn = "\xe2\x98\x83.example"; // <snowman>.example
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--n3h.example");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--n3h.example");
idn = "\xe2\x98\x83."; // <snowman>.
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--n3h.");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--n3h.");
idn = "\xe2\x98\x83"; // <snowman>
assert(DNS::isIDN(idn));
assert(DNS::encodeIDN(idn) == "xn--n3h");
assertTrue (DNS::isIDN(idn));
assertTrue (DNS::encodeIDN(idn) == "xn--n3h");
std::string dn = "www.pocoproject.org";
assert (!DNS::isIDN(dn));
assert (DNS::encodeIDN(dn) == "www.pocoproject.org");
assertTrue (!DNS::isIDN(dn));
assertTrue (DNS::encodeIDN(dn) == "www.pocoproject.org");
}
void DNSTest::testDecodeIDN()
{
std::string enc("xn--dmin-moa0i.example");
assert (DNS::isEncodedIDN(enc));
assert (DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in.example"); // d"om"ain.example
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in.example"); // d"om"ain.example
enc = ".xn--dmin-moa0i.example";
assert(DNS::isEncodedIDN(enc));
assert(DNS::decodeIDN(enc) == ".d\xc3\xb6m\xc3\xa4in.example"); // .d"om"ain.example
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == ".d\xc3\xb6m\xc3\xa4in.example"); // .d"om"ain.example
enc = "xn--dmin-moa0i.example.";
assert(DNS::isEncodedIDN(enc));
assert(DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in.example."); // d"om"ain.example.
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in.example."); // d"om"ain.example.
enc = "xn--dmin-moa0i";
assert(DNS::isEncodedIDN(enc));
assert(DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in"); // d"om"ain
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "d\xc3\xb6m\xc3\xa4in"); // d"om"ain
enc = "foo.xn--bcdf-9na9b.example";
assert (DNS::isEncodedIDN(enc));
assert (DNS::decodeIDN(enc) == "foo.\xc3\xa2""bcd\xc3\xa9""f.example"); // foo.^abcd'ef.example
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "foo.\xc3\xa2""bcd\xc3\xa9""f.example"); // foo.^abcd'ef.example
enc = "xn--n3h.example";
assert (DNS::isEncodedIDN(enc));
assert (DNS::decodeIDN(enc) == "\xe2\x98\x83.example"); // <snowman>.example
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "\xe2\x98\x83.example"); // <snowman>.example
enc = "xn--n3h.";
assert(DNS::isEncodedIDN(enc));
assert(DNS::decodeIDN(enc) == "\xe2\x98\x83."); // <snowman>.
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "\xe2\x98\x83."); // <snowman>.
enc = "xn--n3h";
assert(DNS::isEncodedIDN(enc));
assert(DNS::decodeIDN(enc) == "\xe2\x98\x83"); // <snowman>
assertTrue (DNS::isEncodedIDN(enc));
assertTrue (DNS::decodeIDN(enc) == "\xe2\x98\x83"); // <snowman>
std::string dn = "www.pocoproject.org";
assert (!DNS::isEncodedIDN(dn));
assert (DNS::decodeIDN(dn) == "www.pocoproject.org");
assertTrue (!DNS::isEncodedIDN(dn));
assertTrue (DNS::decodeIDN(dn) == "www.pocoproject.org");
}

30
Net/testsuite/src/DatagramSocketTest.cpp
View File

@@ -51,10 +51,10 @@ void DatagramSocketTest::testEcho()
char buffer[256];
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
int n = ss.sendBytes("hello", 5);
assert (n == 5);
assertTrue (n == 5);
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -64,14 +64,14 @@ void DatagramSocketTest::testSendToReceiveFrom()
UDPEchoServer echoServer(SocketAddress("127.0.0.1", 0));
DatagramSocket ss(SocketAddress::IPv4);
int n = ss.sendTo("hello", 5, SocketAddress("127.0.0.1", echoServer.port()));
assert (n == 5);
assertTrue (n == 5);
char buffer[256];
SocketAddress sa;
n = ss.receiveFrom(buffer, sizeof(buffer), sa);
assert (sa.host() == echoServer.address().host());
assert (sa.port() == echoServer.port());
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (sa.host() == echoServer.address().host());
assertTrue (sa.port() == echoServer.port());
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -83,10 +83,10 @@ void DatagramSocketTest::testUnbound()
char buffer[256];
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
int n = ss.sendBytes("hello", 5);
assert (n == 5);
assertTrue (n == 5);
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -120,15 +120,15 @@ void DatagramSocketTest::testBroadcast()
poco_socklen_t len = sizeof(opt);
ss.impl()->setRawOption(IPPROTO_IP, IP_ONESBCAST, (const char*) &opt, len);
ss.impl()->getRawOption(IPPROTO_IP, IP_ONESBCAST, &opt, len);
assert (opt == 1);
assertTrue (opt == 1);
#endif
int n = ss.sendTo("hello", 5, sa);
assert (n == 5);
assertTrue (n == 5);
char buffer[256] = { 0 };
n = ss.receiveBytes(buffer, 5);
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}

36
Net/testsuite/src/DialogSocketTest.cpp
View File

@@ -40,53 +40,53 @@ void DialogSocketTest::testDialogSocket()
ds.sendMessage("Hello, world!");
std::string str;
ds.receiveMessage(str);
assert (str == "Hello, world!");
assertTrue (str == "Hello, world!");
ds.sendString("Hello, World!\n");
ds.receiveMessage(str);
assert (str == "Hello, World!");
assertTrue (str == "Hello, World!");
ds.sendMessage("EHLO", "appinf.com");
ds.receiveMessage(str);
assert (str == "EHLO appinf.com");
assertTrue (str == "EHLO appinf.com");
ds.sendMessage("PUT", "local.txt", "remote.txt");
ds.receiveMessage(str);
assert (str == "PUT local.txt remote.txt");
assertTrue (str == "PUT local.txt remote.txt");
ds.sendMessage("220 Hello, world!");
int status = ds.receiveStatusMessage(str);
assert (status == 220);
assert (str == "220 Hello, world!");
assertTrue (status == 220);
assertTrue (str == "220 Hello, world!");
ds.sendString("220-line1\r\n220 line2\r\n");
status = ds.receiveStatusMessage(str);
assert (status == 220);
assert (str == "220-line1\n220 line2");
assertTrue (status == 220);
assertTrue (str == "220-line1\n220 line2");
ds.sendString("220-line1\r\nline2\r\n220 line3\r\n");
status = ds.receiveStatusMessage(str);
assert (status == 220);
assert (str == "220-line1\nline2\n220 line3");
assertTrue (status == 220);
assertTrue (str == "220-line1\nline2\n220 line3");
ds.sendMessage("Hello, world!");
status = ds.receiveStatusMessage(str);
assert (status == 0);
assert (str == "Hello, world!");
assertTrue (status == 0);
assertTrue (str == "Hello, world!");
ds.sendString("Header\nMore Bytes");
status = ds.receiveStatusMessage(str);
assert (status == 0);
assert (str == "Header");
assertTrue (status == 0);
assertTrue (str == "Header");
char buffer[16];
int n = ds.receiveRawBytes(buffer, sizeof(buffer));
assert (n == 10);
assert (std::memcmp(buffer, "More Bytes", 10) == 0);
assertTrue (n == 10);
assertTrue (std::memcmp(buffer, "More Bytes", 10) == 0);
ds.sendString("Even More Bytes");
n = ds.receiveRawBytes(buffer, sizeof(buffer));
assert (n == 15);
assert (std::memcmp(buffer, "Even More Bytes", 15) == 0);
assertTrue (n == 15);
assertTrue (std::memcmp(buffer, "Even More Bytes", 15) == 0);
}

118
Net/testsuite/src/FTPClientSessionTest.cpp
View File

@@ -78,13 +78,13 @@ void FTPClientSessionTest::login(DialogServer& server, FTPClientSession& session
server.addResponse("200 Type set to I");
session.login("user", "password");
std::string cmd = server.popCommand();
assert (cmd == "USER user");
assertTrue (cmd == "USER user");
cmd = server.popCommand();
assert (cmd == "PASS password");
assertTrue (cmd == "PASS password");
cmd = server.popCommand();
assert (cmd == "TYPE I");
assertTrue (cmd == "TYPE I");
assert (session.getFileType() == FTPClientSession::TYPE_BINARY);
assertTrue (session.getFileType() == FTPClientSession::TYPE_BINARY);
}
@@ -93,25 +93,25 @@ void FTPClientSessionTest::testLogin1()
DialogServer server;
server.addResponse("220 localhost FTP ready");
FTPClientSession session("127.0.0.1", server.port());
assert (session.isOpen());
assert (!session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (!session.isLoggedIn());
login(server, session);
assert (session.isOpen());
assert (session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (session.isLoggedIn());
server.addResponse("221 Good Bye");
session.logout();
assert (session.isOpen());
assert (!session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (!session.isLoggedIn());
server.clearCommands();
server.clearResponses();
login(server, session);
assert (session.isOpen());
assert (session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (session.isLoggedIn());
server.addResponse("221 Good Bye");
session.close();
assert (!session.isOpen());
assert (!session.isLoggedIn());
assertTrue (!session.isOpen());
assertTrue (!session.isLoggedIn());
}
@@ -124,12 +124,12 @@ void FTPClientSessionTest::testLogin2()
server.addResponse("200 Type set to I");
Poco::UInt16 serverPort = server.port();
FTPClientSession session("127.0.0.1", serverPort, "user", "password");
assert (session.isOpen());
assert (session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (session.isLoggedIn());
server.addResponse("221 Good Bye");
session.close();
assert (!session.isOpen());
assert (!session.isLoggedIn());
assertTrue (!session.isOpen());
assertTrue (!session.isLoggedIn());
server.clearCommands();
server.clearResponses();
@@ -138,12 +138,12 @@ void FTPClientSessionTest::testLogin2()
server.addResponse("230 Welcome");
server.addResponse("200 Type set to I");
session.open("127.0.0.1", serverPort, "user", "password");
assert (session.isOpen());
assert (session.isLoggedIn());
assertTrue (session.isOpen());
assertTrue (session.isLoggedIn());
server.addResponse("221 Good Bye");
session.close();
assert (!session.isOpen());
assert (!session.isLoggedIn());
assertTrue (!session.isOpen());
assertTrue (!session.isLoggedIn());
}
@@ -155,13 +155,13 @@ void FTPClientSessionTest::testLogin3()
server.addResponse("230 Welcome");
server.addResponse("200 Type set to I");
FTPClientSession session;
assert (!session.isOpen());
assert (!session.isLoggedIn());
assertTrue (!session.isOpen());
assertTrue (!session.isLoggedIn());
session.open("127.0.0.1", server.port(), "user", "password");
server.addResponse("221 Good Bye");
session.close();
assert (!session.isOpen());
assert (!session.isLoggedIn());
assertTrue (!session.isOpen());
assertTrue (!session.isLoggedIn());
}
@@ -214,53 +214,53 @@ void FTPClientSessionTest::testCommands()
FTPClientSession session("127.0.0.1", server.port());
session.login("user", "password");
std::string cmd = server.popCommand();
assert (cmd == "USER user");
assertTrue (cmd == "USER user");
cmd = server.popCommand();
assert (cmd == "PASS password");
assertTrue (cmd == "PASS password");
cmd = server.popCommand();
assert (cmd == "TYPE I");
assertTrue (cmd == "TYPE I");
// systemType
server.clearCommands();
server.addResponse("215 UNIX Type: L8 Version: dummyFTP 1.0");
std::string type = session.systemType();
cmd = server.popCommand();
assert (cmd == "SYST");
assert (type == "UNIX Type: L8 Version: dummyFTP 1.0");
assertTrue (cmd == "SYST");
assertTrue (type == "UNIX Type: L8 Version: dummyFTP 1.0");
// getWorkingDirectory
server.addResponse("257 \"/usr/test\" is current directory");
std::string cwd = session.getWorkingDirectory();
cmd = server.popCommand();
assert (cmd == "PWD");
assert (cwd == "/usr/test");
assertTrue (cmd == "PWD");
assertTrue (cwd == "/usr/test");
// getWorkingDirectory (quotes in filename)
server.addResponse("257 \"\"\"quote\"\"\" is current directory");
cwd = session.getWorkingDirectory();
cmd = server.popCommand();
assert (cmd == "PWD");
assert (cwd == "\"quote\"");
assertTrue (cmd == "PWD");
assertTrue (cwd == "\"quote\"");
// setWorkingDirectory
server.addResponse("250 CWD OK");
session.setWorkingDirectory("test");
cmd = server.popCommand();
assert (cmd == "CWD test");
assertTrue (cmd == "CWD test");
server.addResponse("250 CDUP OK");
session.cdup();
cmd = server.popCommand();
assert (cmd == "CDUP");
assertTrue (cmd == "CDUP");
// rename
server.addResponse("350 File exists, send destination name");
server.addResponse("250 Rename OK");
session.rename("old.txt", "new.txt");
cmd = server.popCommand();
assert (cmd == "RNFR old.txt");
assertTrue (cmd == "RNFR old.txt");
cmd = server.popCommand();
assert (cmd == "RNTO new.txt");
assertTrue (cmd == "RNTO new.txt");
// rename (failing)
server.addResponse("550 not found");
@@ -278,7 +278,7 @@ void FTPClientSessionTest::testCommands()
server.addResponse("250 delete ok");
session.remove("test.txt");
cmd = server.popCommand();
assert (cmd == "DELE test.txt");
assertTrue (cmd == "DELE test.txt");
// remove (failing)
server.addResponse("550 not found");
@@ -296,7 +296,7 @@ void FTPClientSessionTest::testCommands()
server.addResponse("257 dir created");
session.createDirectory("foo");
cmd = server.popCommand();
assert (cmd == "MKD foo");
assertTrue (cmd == "MKD foo");
// createDirectory (failing)
server.addResponse("550 exists");
@@ -314,7 +314,7 @@ void FTPClientSessionTest::testCommands()
server.addResponse("250 RMD OK");
session.removeDirectory("foo");
cmd = server.popCommand();
assert (cmd == "RMD foo");
assertTrue (cmd == "RMD foo");
// removeDirectory (failing)
server.addResponse("550 not found");
@@ -353,10 +353,10 @@ void FTPClientSessionTest::testDownloadPORT()
ActiveResult<std::string> result = dl.download("test.txt");
std::string cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "EPRT");
assertTrue (cmd.substr(0, 4) == "EPRT");
cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "PORT");
assertTrue (cmd.substr(0, 4) == "PORT");
std::string dummy;
int x, lo, hi;
@@ -369,7 +369,7 @@ void FTPClientSessionTest::testDownloadPORT()
int port = hi*256 + lo;
cmd = server.popCommandWait();
assert (cmd == "RETR test.txt");
assertTrue (cmd == "RETR test.txt");
SocketAddress sa("127.0.0.1", (Poco::UInt16) port);
DialogSocket dataSock;
@@ -381,7 +381,7 @@ void FTPClientSessionTest::testDownloadPORT()
result.wait();
std::string received = result.data();
assert (received == data);
assertTrue (received == data);
server.addResponse("221 Good Bye");
session.close();
@@ -407,7 +407,7 @@ void FTPClientSessionTest::testDownloadEPRT()
ActiveResult<std::string> result = dl.download("test.txt");
std::string cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "EPRT");
assertTrue (cmd.substr(0, 4) == "EPRT");
std::string dummy;
char c;
@@ -417,7 +417,7 @@ void FTPClientSessionTest::testDownloadEPRT()
istr >> dummy >> c >> d >> c >> d >> c >> d >> c >> d >> c >> d >> c >> port >> c;
cmd = server.popCommandWait();
assert (cmd == "RETR test.txt");
assertTrue (cmd == "RETR test.txt");
SocketAddress sa("127.0.0.1", (Poco::UInt16) port);
DialogSocket dataSock;
@@ -429,7 +429,7 @@ void FTPClientSessionTest::testDownloadEPRT()
result.wait();
std::string received = result.data();
assert (received == data);
assertTrue (received == data);
server.addResponse("221 Good Bye");
session.close();
@@ -462,7 +462,7 @@ void FTPClientSessionTest::testDownloadPASV()
StreamCopier::copyStream(istr, dataStr);
session.endDownload();
std::string s(dataStr.str());
assert (s == "This is some data\r\n");
assertTrue (s == "This is some data\r\n");
server.addResponse("221 Good Bye");
session.close();
@@ -492,12 +492,12 @@ void FTPClientSessionTest::testDownloadEPSV()
StreamCopier::copyStream(istr, dataStr);
session.endDownload();
std::string s(dataStr.str());
assert (s == "This is some data\r\n");
assertTrue (s == "This is some data\r\n");
std::string cmd = server.popCommand();
assert (cmd.substr(0, 4) == "EPSV");
assertTrue (cmd.substr(0, 4) == "EPSV");
cmd = server.popCommand();
assert (cmd == "RETR test.txt");
assertTrue (cmd == "RETR test.txt");
server.addResponse("221 Good Bye");
session.close();
@@ -525,12 +525,12 @@ void FTPClientSessionTest::testUpload()
ostr << "This is some data\r\n";
session.endUpload();
std::string s(dataServer.popCommandWait());
assert (s == "This is some data");
assertTrue (s == "This is some data");
std::string cmd = server.popCommand();
assert (cmd.substr(0, 4) == "EPSV");
assertTrue (cmd.substr(0, 4) == "EPSV");
cmd = server.popCommand();
assert (cmd == "STOR test.txt");
assertTrue (cmd == "STOR test.txt");
server.addResponse("221 Good Bye");
session.close();
@@ -560,12 +560,12 @@ void FTPClientSessionTest::testList()
StreamCopier::copyStream(istr, dataStr);
session.endList();
std::string s(dataStr.str());
assert (s == "file1\r\nfile2\r\n");
assertTrue (s == "file1\r\nfile2\r\n");
std::string cmd = server.popCommand();
assert (cmd.substr(0, 4) == "EPSV");
assertTrue (cmd.substr(0, 4) == "EPSV");
cmd = server.popCommand();
assert (cmd == "NLST");
assertTrue (cmd == "NLST");
server.addResponse("221 Good Bye");
session.close();

8
Net/testsuite/src/FTPStreamFactoryTest.cpp
View File

@@ -90,7 +90,7 @@ void FTPStreamFactoryTest::testDownload()
pStr.reset();
std::string s(dataStr.str());
assert (s == "line1\r\nline2\r\n");
assertTrue (s == "line1\r\nline2\r\n");
}
@@ -132,7 +132,7 @@ void FTPStreamFactoryTest::testList()
pStr.reset();
std::string s(dataStr.str());
assert (s == "file1\r\nfile2\r\n");
assertTrue (s == "file1\r\nfile2\r\n");
}
@@ -174,7 +174,7 @@ void FTPStreamFactoryTest::testUserInfo()
pStr.reset();
std::string s(dataStr.str());
assert (s == "line1\r\nline2\r\n");
assertTrue (s == "line1\r\nline2\r\n");
}
@@ -217,7 +217,7 @@ void FTPStreamFactoryTest::testPasswordProvider()
pStr.reset();
std::string s(dataStr.str());
assert (s == "line1\r\nline2\r\n");
assertTrue (s == "line1\r\nline2\r\n");
}

98
Net/testsuite/src/HTMLFormTest.cpp
View File

@@ -95,7 +95,7 @@ void HTMLFormTest::testWriteUrl()
std::ostringstream ostr;
form.write(ostr);
std::string s = ostr.str();
assert (s == "field1=value1&field2=value%202&field3=value%3D3&field4=value%264&field5=value%2B5");
assertTrue (s == "field1=value1&field2=value%202&field3=value%3D3&field4=value%264&field5=value%2B5");
}
@@ -115,7 +115,7 @@ void HTMLFormTest::testWriteMultipart()
std::ostringstream ostr;
form.write(ostr, "MIME_boundary_0123456789");
std::string s = ostr.str();
assert (s ==
assertTrue (s ==
"--MIME_boundary_0123456789\r\n"
"Content-Disposition: form-data; name=\"field1\"\r\n"
"\r\n"
@@ -145,7 +145,7 @@ void HTMLFormTest::testWriteMultipart()
"This is another attachment\r\n"
"--MIME_boundary_0123456789--\r\n"
);
assert(s.length() == form.calculateContentLength());
assertTrue (s.length() == form.calculateContentLength());
}
@@ -153,11 +153,11 @@ void HTMLFormTest::testReadUrlGET()
{
HTTPRequest req("GET", "/form.cgi?field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
HTMLForm form(req);
assert (form.size() == 4);
assert (form["field1"] == "value1");
assert (form["field2"] == "value 2");
assert (form["field3"] == "value=3");
assert (form["field4"] == "value&4");
assertTrue (form.size() == 4);
assertTrue (form["field1"] == "value1");
assertTrue (form["field2"] == "value 2");
assertTrue (form["field3"] == "value=3");
assertTrue (form["field4"] == "value&4");
}
@@ -165,22 +165,22 @@ void HTMLFormTest::testReadUrlGETMultiple()
{
HTTPRequest req("GET", "/form.cgi?field1=value1&field1=value%202&field1=value%3D3&field1=value%264");
HTMLForm form(req);
assert (form.size() == 4);
assertTrue (form.size() == 4);
HTMLForm::ConstIterator it = form.find("field1");
assert (it != form.end());
assert (it->first == "field1" && it->second == "value1");
assertTrue (it != form.end());
assertTrue (it->first == "field1" && it->second == "value1");
++it;
assert (it != form.end());
assert (it->first == "field1" && it->second == "value 2");
assertTrue (it != form.end());
assertTrue (it->first == "field1" && it->second == "value 2");
++it;
assert (it != form.end());
assert (it->first == "field1" && it->second == "value=3");
assertTrue (it != form.end());
assertTrue (it->first == "field1" && it->second == "value=3");
++it;
assert (it != form.end());
assert (it->first == "field1" && it->second == "value&4");
assertTrue (it != form.end());
assertTrue (it->first == "field1" && it->second == "value&4");
++it;
assert (it == form.end());
assertTrue (it == form.end());
}
@@ -189,12 +189,12 @@ void HTMLFormTest::testReadUrlPOST()
HTTPRequest req("POST", "/form.cgi?field0=value0");
std::istringstream istr("field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
HTMLForm form(req, istr);
assert (form.size() == 5);
assert (form["field0"] == "value0");
assert (form["field1"] == "value1");
assert (form["field2"] == "value 2");
assert (form["field3"] == "value=3");
assert (form["field4"] == "value&4");
assertTrue (form.size() == 5);
assertTrue (form["field0"] == "value0");
assertTrue (form["field1"] == "value1");
assertTrue (form["field2"] == "value 2");
assertTrue (form["field3"] == "value=3");
assertTrue (form["field4"] == "value&4");
}
@@ -203,12 +203,12 @@ void HTMLFormTest::testReadUrlPUT()
HTTPRequest req("PUT", "/form.cgi?field0=value0");
std::istringstream istr("field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
HTMLForm form(req, istr);
assert (form.size() == 5);
assert (form["field0"] == "value0");
assert (form["field1"] == "value1");
assert (form["field2"] == "value 2");
assert (form["field3"] == "value=3");
assert (form["field4"] == "value&4");
assertTrue (form.size() == 5);
assertTrue (form["field0"] == "value0");
assertTrue (form["field1"] == "value1");
assertTrue (form["field2"] == "value 2");
assertTrue (form["field3"] == "value=3");
assertTrue (form["field4"] == "value&4");
}
@@ -217,12 +217,12 @@ void HTMLFormTest::testReadUrlBOM()
HTTPRequest req("PUT", "/form.cgi?field0=value0");
std::istringstream istr("\357\273\277field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
HTMLForm form(req, istr);
assert (form.size() == 5);
assert (form["field0"] == "value0");
assert (form["field1"] == "value1");
assert (form["field2"] == "value 2");
assert (form["field3"] == "value=3");
assert (form["field4"] == "value&4");
assertTrue (form.size() == 5);
assertTrue (form["field0"] == "value0");
assertTrue (form["field1"] == "value1");
assertTrue (form["field2"] == "value 2");
assertTrue (form["field3"] == "value=3");
assertTrue (form["field4"] == "value&4");
}
@@ -257,15 +257,15 @@ void HTMLFormTest::testReadMultipart()
req.setContentType(HTMLForm::ENCODING_MULTIPART + "; boundary=\"MIME_boundary_0123456789\"");
StringPartHandler sah;
HTMLForm form(req, istr, sah);
assert (form.size() == 4);
assert (form["field1"] == "value1");
assert (form["field2"] == "value 2");
assert (form["field3"] == "value=3");
assert (form["field4"] == "value&4");
assertTrue (form.size() == 4);
assertTrue (form["field1"] == "value1");
assertTrue (form["field2"] == "value 2");
assertTrue (form["field3"] == "value=3");
assertTrue (form["field4"] == "value&4");
assert (sah.type() == "text/plain");
assert (sah.disp() == "file; name=\"attachment1\"; filename=\"att1.txt\"");
assert (sah.data() == "This is an attachment");
assertTrue (sah.type() == "text/plain");
assertTrue (sah.disp() == "file; name=\"attachment1\"; filename=\"att1.txt\"");
assertTrue (sah.data() == "This is an attachment");
}
@@ -279,7 +279,7 @@ void HTMLFormTest::testSubmit1()
HTTPRequest req("GET", "/form.cgi");
form.prepareSubmit(req);
assert (req.getURI() == "/form.cgi?field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
assertTrue (req.getURI() == "/form.cgi?field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
}
@@ -293,7 +293,7 @@ void HTMLFormTest::testSubmit2()
HTTPRequest req("POST", "/form.cgi");
form.prepareSubmit(req);
assert (req.getContentType() == HTMLForm::ENCODING_URL);
assertTrue (req.getContentType() == HTMLForm::ENCODING_URL);
}
@@ -311,8 +311,8 @@ void HTMLFormTest::testSubmit3()
expCT.append("; boundary=\"");
expCT.append(form.boundary());
expCT.append("\"");
assert (req.getContentType() == expCT);
assert (req.getChunkedTransferEncoding());
assertTrue (req.getContentType() == expCT);
assertTrue (req.getChunkedTransferEncoding());
}
@@ -327,7 +327,7 @@ void HTMLFormTest::testSubmit4()
HTTPRequest req("GET", "/form.cgi");
form.prepareSubmit(req);
assert (req.getURI() == "/form.cgi?field1=value1&field1=value%202&field1=value%3D3&field1=value%264");
assertTrue (req.getURI() == "/form.cgi?field1=value1&field1=value%202&field1=value%3D3&field1=value%264");
}

118
Net/testsuite/src/HTTPClientSessionTest.cpp
View File

@@ -46,11 +46,11 @@ void HTTPClientSessionTest::testGetSmall()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPTestServer::SMALL_BODY);
assertTrue (ostr.str() == HTTPTestServer::SMALL_BODY);
}
@@ -62,11 +62,11 @@ void HTTPClientSessionTest::testGetLarge()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
}
@@ -78,10 +78,10 @@ void HTTPClientSessionTest::testHead()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
assert (StreamCopier::copyStream(rs, ostr) == 0);
assertTrue (StreamCopier::copyStream(rs, ostr) == 0);
}
@@ -95,10 +95,10 @@ void HTTPClientSessionTest::testPostSmallIdentity()
s.sendRequest(request) << body;
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == body.length());
assertTrue (response.getContentLength() == body.length());
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -113,10 +113,10 @@ void HTTPClientSessionTest::testPostLargeIdentity()
s.sendRequest(request) << body;
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == body.length());
assertTrue (response.getContentLength() == body.length());
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -130,11 +130,11 @@ void HTTPClientSessionTest::testPostSmallChunked()
s.sendRequest(request) << body;
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getChunkedTransferEncoding());
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -150,11 +150,11 @@ void HTTPClientSessionTest::testPostLargeChunked()
os.flush();
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getChunkedTransferEncoding());
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr, 16000);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -167,11 +167,11 @@ void HTTPClientSessionTest::testPostSmallClose()
s.sendRequest(request) << body;
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (!response.getChunkedTransferEncoding());
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (!response.getChunkedTransferEncoding());
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -184,11 +184,11 @@ void HTTPClientSessionTest::testPostLargeClose()
s.sendRequest(request) << body;
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (!response.getChunkedTransferEncoding());
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (!response.getChunkedTransferEncoding());
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -201,42 +201,42 @@ void HTTPClientSessionTest::testKeepAlive()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs1 = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assert (response.getContentType() == "text/plain");
assert (response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getKeepAlive());
std::ostringstream ostr1;
assert (StreamCopier::copyStream(rs1, ostr1) == 0);
assertTrue (StreamCopier::copyStream(rs1, ostr1) == 0);
request.setMethod(HTTPRequest::HTTP_GET);
request.setURI("/small");
s.sendRequest(request);
std::istream& rs2 = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assert (response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPTestServer::SMALL_BODY.length());
assertTrue (response.getKeepAlive());
std::ostringstream ostr2;
StreamCopier::copyStream(rs2, ostr2);
assert (ostr2.str() == HTTPTestServer::SMALL_BODY);
assertTrue (ostr2.str() == HTTPTestServer::SMALL_BODY);
request.setMethod(HTTPRequest::HTTP_GET);
request.setURI("/large");
s.sendRequest(request);
std::istream& rs3 = s.receiveResponse(response);
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getChunkedTransferEncoding());
assert (response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getKeepAlive());
std::ostringstream ostr3;
StreamCopier::copyStream(rs3, ostr3);
assert (ostr3.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr3.str() == HTTPTestServer::LARGE_BODY);
request.setMethod(HTTPRequest::HTTP_HEAD);
request.setURI("/large");
s.sendRequest(request);
std::istream& rs4= s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assert (!response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
assertTrue (!response.getKeepAlive());
std::ostringstream ostr4;
assert (StreamCopier::copyStream(rs4, ostr4) == 0);
assertTrue (StreamCopier::copyStream(rs4, ostr4) == 0);
}
@@ -249,11 +249,11 @@ void HTTPClientSessionTest::testProxy()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
}
@@ -267,13 +267,13 @@ void HTTPClientSessionTest::testProxyAuth()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
std::string r = srv.lastRequest();
assert (r.find("Proxy-Authorization: Basic dXNlcjpwYXNz\r\n") != std::string::npos);
assertTrue (r.find("Proxy-Authorization: Basic dXNlcjpwYXNz\r\n") != std::string::npos);
}
@@ -286,15 +286,15 @@ void HTTPClientSessionTest::testBypassProxy()
HTTPClientSession s1("127.0.0.1", 80);
s1.setProxyConfig(proxyConfig);
assert (s1.bypassProxy());
assertTrue (s1.bypassProxy());
HTTPClientSession s2("127.0.0.1", 80);
s2.setProxyConfig(proxyConfig);
assert (s2.bypassProxy());
assertTrue (s2.bypassProxy());
HTTPClientSession s3("www.appinf.com", 80);
s3.setProxyConfig(proxyConfig);
assert (!s3.bypassProxy());
assertTrue (!s3.bypassProxy());
}
@@ -308,14 +308,14 @@ void HTTPClientSessionTest::testExpectContinue()
request.setExpectContinue(true);
s.sendRequest(request) << body;
HTTPResponse response;
assert (s.peekResponse(response));
assert (response.getStatus() == HTTPResponse::HTTP_CONTINUE);
assertTrue (s.peekResponse(response));
assertTrue (response.getStatus() == HTTPResponse::HTTP_CONTINUE);
std::istream& rs = s.receiveResponse(response);
assert (response.getStatus() == HTTPResponse::HTTP_OK);
assert (response.getContentLength() == body.length());
assertTrue (response.getStatus() == HTTPResponse::HTTP_OK);
assertTrue (response.getContentLength() == body.length());
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == body);
assertTrue (ostr.str() == body);
}
@@ -329,13 +329,13 @@ void HTTPClientSessionTest::testExpectContinueFail()
request.setExpectContinue(true);
s.sendRequest(request) << body;
HTTPResponse response;
assert (!s.peekResponse(response));
assert (response.getStatus() == HTTPResponse::HTTP_BAD_REQUEST);
assertTrue (!s.peekResponse(response));
assertTrue (response.getStatus() == HTTPResponse::HTTP_BAD_REQUEST);
std::istream& rs = s.receiveResponse(response);
assert (response.getStatus() == HTTPResponse::HTTP_BAD_REQUEST);
assertTrue (response.getStatus() == HTTPResponse::HTTP_BAD_REQUEST);
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str().empty());
assertTrue (ostr.str().empty());
}

46
Net/testsuite/src/HTTPCookieTest.cpp
View File

@@ -46,64 +46,64 @@ HTTPCookieTest::~HTTPCookieTest()
void HTTPCookieTest::testCookie()
{
HTTPCookie cookie("name", "value");
assert (cookie.getName() == "name");
assert (cookie.getValue() == "value");
assert (cookie.toString() == "name=value");
assertTrue (cookie.getName() == "name");
assertTrue (cookie.getValue() == "value");
assertTrue (cookie.toString() == "name=value");
cookie.setPath("/");
assert (cookie.toString() == "name=value; path=/");
assertTrue (cookie.toString() == "name=value; path=/");
cookie.setComment("comment");
assert (cookie.toString() == "name=value; path=/");
assertTrue (cookie.toString() == "name=value; path=/");
cookie.setDomain("appinf.com");
assert (cookie.toString() == "name=value; domain=appinf.com; path=/");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/");
cookie.setSecure(true);
assert (cookie.toString() == "name=value; domain=appinf.com; path=/; secure");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/; secure");
cookie.setHttpOnly(true);
assert (cookie.toString() == "name=value; domain=appinf.com; path=/; secure; HttpOnly");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/; secure; HttpOnly");
cookie.setPriority("Low");
assert (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=Low; secure; HttpOnly");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=Low; secure; HttpOnly");
cookie.setPriority("Medium");
assert (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=Medium; secure; HttpOnly");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=Medium; secure; HttpOnly");
cookie.setPriority("High");
assert (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=High; secure; HttpOnly");
assertTrue (cookie.toString() == "name=value; domain=appinf.com; path=/; Priority=High; secure; HttpOnly");
cookie.setPriority("");
cookie.setHttpOnly(false);
cookie.setVersion(1);
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; secure; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; secure; Version=\"1\"");
cookie.setSecure(false);
cookie.setMaxAge(100);
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Max-Age=\"100\"; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Max-Age=\"100\"; Version=\"1\"");
cookie.setHttpOnly(true);
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
cookie.setPriority("Low");
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"Low\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"Low\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
cookie.setPriority("Medium");
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"Medium\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"Medium\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
cookie.setPriority("High");
assert (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"High\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
assertTrue (cookie.toString() == "name=\"value\"; Comment=\"comment\"; Domain=\"appinf.com\"; Path=\"/\"; Priority=\"High\"; Max-Age=\"100\"; HttpOnly; Version=\"1\"");
}
void HTTPCookieTest::testEscape()
{
std::string escaped = HTTPCookie::escape("this is a test.");
assert (escaped == "this%20is%20a%20test.");
assertTrue (escaped == "this%20is%20a%20test.");
escaped = HTTPCookie::escape("\n\t@,;\"'");
assert (escaped == "%0A%09@%2C%3B%22%27");
assertTrue (escaped == "%0A%09@%2C%3B%22%27");
}
void HTTPCookieTest::testUnescape()
{
std::string unescaped = HTTPCookie::unescape("this%20is%20a%20test!");
assert (unescaped == "this is a test!");
assertTrue (unescaped == "this is a test!");
unescaped = HTTPCookie::unescape("%0a%09@%2c%3b%22%27");
assert (unescaped == "\n\t@,;\"'");
assertTrue (unescaped == "\n\t@,;\"'");
}
@@ -174,11 +174,11 @@ void HTTPCookieTest::testCookieExpiry(DateTime expiryTime)
//assert that the cookie's expiry time reflects the time passed to
//its constructor, within a delta of the lifetime of the cookie
assert (cookieExpireTime - expiryTime <= delta);
assertTrue (cookieExpireTime - expiryTime <= delta);
//assert that the cookie's max age is the number of seconds between
//the creation of the cookie and the expiry time passed to its
//constuctor, within a delta of the lifetime of the cookie
assert (cookieMaxAge - expectedMaxAge <= delta.seconds());
assertTrue (cookieMaxAge - expectedMaxAge <= delta.seconds());
}

126
Net/testsuite/src/HTTPCredentialsTest.cpp
View File

@@ -43,36 +43,36 @@ HTTPCredentialsTest::~HTTPCredentialsTest()
void HTTPCredentialsTest::testBasicCredentials()
{
HTTPRequest request;
assert (!request.hasCredentials());
assertTrue (!request.hasCredentials());
HTTPBasicCredentials cred("user", "secret");
cred.authenticate(request);
assert (request.hasCredentials());
assertTrue (request.hasCredentials());
std::string scheme;
std::string info;
request.getCredentials(scheme, info);
assert (scheme == "Basic");
assert (info == "dXNlcjpzZWNyZXQ=");
assertTrue (scheme == "Basic");
assertTrue (info == "dXNlcjpzZWNyZXQ=");
HTTPBasicCredentials cred2(request);
assert (cred2.getUsername() == "user");
assert (cred2.getPassword() == "secret");
assertTrue (cred2.getUsername() == "user");
assertTrue (cred2.getPassword() == "secret");
}
void HTTPCredentialsTest::testProxyBasicCredentials()
{
HTTPRequest request;
assert (!request.hasProxyCredentials());
assertTrue (!request.hasProxyCredentials());
HTTPBasicCredentials cred("user", "secret");
cred.proxyAuthenticate(request);
assert (request.hasProxyCredentials());
assertTrue (request.hasProxyCredentials());
std::string scheme;
std::string info;
request.getProxyCredentials(scheme, info);
assert (scheme == "Basic");
assert (info == "dXNlcjpzZWNyZXQ=");
assertTrue (scheme == "Basic");
assertTrue (info == "dXNlcjpzZWNyZXQ=");
}
@@ -93,8 +93,8 @@ void HTTPCredentialsTest::testBadCredentials()
request.setCredentials("Test", "SomeData");
request.getCredentials(scheme, info);
assert (scheme == "Test");
assert (info == "SomeData");
assertTrue (scheme == "Test");
assertTrue (info == "SomeData");
try
{
@@ -112,34 +112,34 @@ void HTTPCredentialsTest::testAuthenticationParams()
const std::string authInfo("nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", response=\"40e4889cfbd0e561f71e3107a2863bc4\", uri=\"/digest/\", username=\"user\"");
HTTPAuthenticationParams params(authInfo);
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params["realm"] == "TestDigest");
assert (params["response"] == "40e4889cfbd0e561f71e3107a2863bc4");
assert (params["uri"] == "/digest/");
assert (params["username"] == "user");
assert (params.size() == 5);
assert (params.toString() == authInfo);
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["response"] == "40e4889cfbd0e561f71e3107a2863bc4");
assertTrue (params["uri"] == "/digest/");
assertTrue (params["username"] == "user");
assertTrue (params.size() == 5);
assertTrue (params.toString() == authInfo);
params.clear();
HTTPRequest request;
request.set("Authorization", "Digest " + authInfo);
params.fromRequest(request);
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params["realm"] == "TestDigest");
assert (params["response"] == "40e4889cfbd0e561f71e3107a2863bc4");
assert (params["uri"] == "/digest/");
assert (params["username"] == "user");
assert (params.size() == 5);
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["response"] == "40e4889cfbd0e561f71e3107a2863bc4");
assertTrue (params["uri"] == "/digest/");
assertTrue (params["username"] == "user");
assertTrue (params.size() == 5);
params.clear();
HTTPResponse response;
response.set("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
params.fromResponse(response);
assert (params["realm"] == "TestDigest");
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params.size() == 2);
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params.size() == 2);
}
@@ -150,9 +150,9 @@ void HTTPCredentialsTest::testAuthenticationParamsMultipleHeaders()
response.add("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
HTTPAuthenticationParams params(response);
assert (params["realm"] == "TestDigest");
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params.size() == 2);
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params.size() == 2);
}
@@ -164,7 +164,7 @@ void HTTPCredentialsTest::testDigestCredentials()
response.set("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
creds.authenticate(request, response);
std::string auth = request.get("Authorization");
assert (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
assertTrue (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
}
@@ -177,16 +177,16 @@ void HTTPCredentialsTest::testDigestCredentialsQoP()
creds.authenticate(request, response);
HTTPAuthenticationParams params(request);
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params["realm"] == "TestDigest");
assert (params["response"] != "40e4889cfbd0e561f71e3107a2863bc4");
assert (params["uri"] == "/digest/");
assert (params["username"] == "user");
assert (params["opaque"] == "opaque");
assert (params["cnonce"] != "");
assert (params["nc"] == "00000001");
assert (params["qop"] == "auth");
assert (params.size() == 9);
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["response"] != "40e4889cfbd0e561f71e3107a2863bc4");
assertTrue (params["uri"] == "/digest/");
assertTrue (params["username"] == "user");
assertTrue (params["opaque"] == "opaque");
assertTrue (params["cnonce"] != "");
assertTrue (params["nc"] == "00000001");
assertTrue (params["qop"] == "auth");
assertTrue (params.size() == 9);
std::string cnonce = params["cnonce"];
std::string aresp = params["response"];
@@ -195,16 +195,16 @@ void HTTPCredentialsTest::testDigestCredentialsQoP()
creds.updateAuthInfo(request);
params.fromRequest(request);
assert (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assert (params["realm"] == "TestDigest");
assert (params["response"] != aresp);
assert (params["uri"] == "/digest/");
assert (params["username"] == "user");
assert (params["opaque"] == "opaque");
assert (params["cnonce"] == cnonce);
assert (params["nc"] == "00000002");
assert (params["qop"] == "auth");
assert (params.size() == 9);
assertTrue (params["nonce"] == "212573bb90170538efad012978ab811f%lu");
assertTrue (params["realm"] == "TestDigest");
assertTrue (params["response"] != aresp);
assertTrue (params["uri"] == "/digest/");
assertTrue (params["username"] == "user");
assertTrue (params["opaque"] == "opaque");
assertTrue (params["cnonce"] == cnonce);
assertTrue (params["nc"] == "00000002");
assertTrue (params["qop"] == "auth");
assertTrue (params.size() == 9);
}
@@ -215,7 +215,7 @@ void HTTPCredentialsTest::testCredentialsBasic()
HTTPResponse response;
response.set("WWW-Authenticate", "Basic realm=\"TestBasic\"");
creds.authenticate(request, response);
assert (request.get("Authorization") == "Basic dXNlcjpzM2NyM3Q=");
assertTrue (request.get("Authorization") == "Basic dXNlcjpzM2NyM3Q=");
}
@@ -226,7 +226,7 @@ void HTTPCredentialsTest::testProxyCredentialsBasic()
HTTPResponse response;
response.set("Proxy-Authenticate", "Basic realm=\"TestBasic\"");
creds.proxyAuthenticate(request, response);
assert (request.get("Proxy-Authorization") == "Basic dXNlcjpzM2NyM3Q=");
assertTrue (request.get("Proxy-Authorization") == "Basic dXNlcjpzM2NyM3Q=");
}
@@ -238,7 +238,7 @@ void HTTPCredentialsTest::testCredentialsDigest()
response.set("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
creds.authenticate(request, response);
std::string auth = request.get("Authorization");
assert (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
assertTrue (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
}
@@ -251,7 +251,7 @@ void HTTPCredentialsTest::testCredentialsDigestMultipleHeaders()
response.add("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
creds.authenticate(request, response);
std::string auth = request.get("Authorization");
assert (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
assertTrue (auth == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
}
@@ -262,7 +262,7 @@ void HTTPCredentialsTest::testProxyCredentialsDigest()
HTTPResponse response;
response.set("Proxy-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
creds.proxyAuthenticate(request, response);
assert (request.get("Proxy-Authorization") == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
assertTrue (request.get("Proxy-Authorization") == "Digest username=\"user\", nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", uri=\"/digest/\", response=\"40e4889cfbd0e561f71e3107a2863bc4\"");
}
@@ -272,8 +272,8 @@ void HTTPCredentialsTest::testExtractCredentials()
std::string username;
std::string password;
HTTPCredentials::extractCredentials(uri, username, password);
assert (username == "user");
assert (password == "s3cr3t");
assertTrue (username == "user");
assertTrue (password == "s3cr3t");
}
@@ -284,10 +284,10 @@ void HTTPCredentialsTest::testVerifyAuthInfo()
HTTPResponse response;
response.set("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\"");
creds.authenticate(request, response);
assert (creds.verifyAuthInfo(request));
assertTrue (creds.verifyAuthInfo(request));
request.set("Authorization", "Digest nonce=\"212573bb90170538efad012978ab811f%lu\", realm=\"TestDigest\", response=\"xxe4889cfbd0e561f71e3107a2863bc4\", uri=\"/digest/\", username=\"user\"");
assert (!creds.verifyAuthInfo(request));
assertTrue (!creds.verifyAuthInfo(request));
}
@@ -298,10 +298,10 @@ void HTTPCredentialsTest::testVerifyAuthInfoQoP()
HTTPResponse response;
response.set("WWW-Authenticate", "Digest realm=\"TestDigest\", nonce=\"212573bb90170538efad012978ab811f%lu\", opaque=\"opaque\", qop=\"auth,auth-int\"");
creds.authenticate(request, response);
assert (creds.verifyAuthInfo(request));
assertTrue (creds.verifyAuthInfo(request));
request.set("Authorization", "Digest cnonce=\"f9c80ffd1c3bc4ee47ed92b704ba75a4\", nc=00000001, nonce=\"212573bb90170538efad012978ab811f%lu\", opaque=\"opaque\", qop=\"auth\", realm=\"TestDigest\", response=\"ff0e90b9aa019120ea0ed6e23ce95d9a\", uri=\"/digest/\", username=\"user\"");
assert (!creds.verifyAuthInfo(request));
assertTrue (!creds.verifyAuthInfo(request));
}

92
Net/testsuite/src/HTTPRequestTest.cpp
View File

@@ -38,7 +38,7 @@ void HTTPRequestTest::testWrite1()
std::ostringstream ostr;
request.write(ostr);
std::string s = ostr.str();
assert (s == "GET / HTTP/1.0\r\n\r\n");
assertTrue (s == "GET / HTTP/1.0\r\n\r\n");
}
@@ -51,7 +51,7 @@ void HTTPRequestTest::testWrite2()
std::ostringstream ostr;
request.write(ostr);
std::string s = ostr.str();
assert (s == "HEAD /index.html HTTP/1.1\r\nHost: localhost\r\nConnection: Keep-Alive\r\nUser-Agent: Poco\r\n\r\n");
assertTrue (s == "HEAD /index.html HTTP/1.1\r\nHost: localhost\r\nConnection: Keep-Alive\r\nUser-Agent: Poco\r\n\r\n");
}
@@ -66,7 +66,7 @@ void HTTPRequestTest::testWrite3()
std::ostringstream ostr;
request.write(ostr);
std::string s = ostr.str();
assert (s == "POST /test.cgi HTTP/1.1\r\nHost: localhost:8000\r\nConnection: Close\r\nUser-Agent: Poco\r\nContent-Length: 100\r\nContent-Type: text/plain\r\n\r\n");
assertTrue (s == "POST /test.cgi HTTP/1.1\r\nHost: localhost:8000\r\nConnection: Close\r\nUser-Agent: Poco\r\nContent-Length: 100\r\nContent-Type: text/plain\r\n\r\n");
}
@@ -79,7 +79,7 @@ void HTTPRequestTest::testWrite4()
std::ostringstream ostr;
request.write(ostr);
std::string s = ostr.str();
assert (s == "HEAD /index.html HTTP/1.1\r\nHost: [fe80::1]:88\r\nConnection: Keep-Alive\r\nUser-Agent: Poco\r\n\r\n");
assertTrue (s == "HEAD /index.html HTTP/1.1\r\nHost: [fe80::1]:88\r\nConnection: Keep-Alive\r\nUser-Agent: Poco\r\n\r\n");
}
@@ -89,11 +89,11 @@ void HTTPRequestTest::testRead1()
std::istringstream istr(s);
HTTPRequest request;
request.read(istr);
assert (request.getMethod() == HTTPRequest::HTTP_GET);
assert (request.getURI() == "/");
assert (request.getVersion() == HTTPMessage::HTTP_1_0);
assert (request.empty());
assert (istr.get() == -1);
assertTrue (request.getMethod() == HTTPRequest::HTTP_GET);
assertTrue (request.getURI() == "/");
assertTrue (request.getVersion() == HTTPMessage::HTTP_1_0);
assertTrue (request.empty());
assertTrue (istr.get() == -1);
}
@@ -103,14 +103,14 @@ void HTTPRequestTest::testRead2()
std::istringstream istr(s);
HTTPRequest request;
request.read(istr);
assert (request.getMethod() == HTTPRequest::HTTP_HEAD);
assert (request.getURI() == "/index.html");
assert (request.getVersion() == HTTPMessage::HTTP_1_1);
assert (request.size() == 3);
assert (request["Connection"] == "Keep-Alive");
assert (request["Host"] == "localhost");
assert (request["User-Agent"] == "Poco");
assert (istr.get() == -1);
assertTrue (request.getMethod() == HTTPRequest::HTTP_HEAD);
assertTrue (request.getURI() == "/index.html");
assertTrue (request.getVersion() == HTTPMessage::HTTP_1_1);
assertTrue (request.size() == 3);
assertTrue (request["Connection"] == "Keep-Alive");
assertTrue (request["Host"] == "localhost");
assertTrue (request["User-Agent"] == "Poco");
assertTrue (istr.get() == -1);
}
@@ -120,16 +120,16 @@ void HTTPRequestTest::testRead3()
std::istringstream istr(s);
HTTPRequest request;
request.read(istr);
assert (request.getMethod() == HTTPRequest::HTTP_POST);
assert (request.getURI() == "/test.cgi");
assert (request.getVersion() == HTTPMessage::HTTP_1_1);
assert (request.size() == 5);
assert (request["Connection"] == "Close");
assert (request["Host"] == "localhost:8000");
assert (request["User-Agent"] == "Poco");
assert (request.getContentType() == "text/plain");
assert (request.getContentLength() == 100);
assert (istr.get() == -1);
assertTrue (request.getMethod() == HTTPRequest::HTTP_POST);
assertTrue (request.getURI() == "/test.cgi");
assertTrue (request.getVersion() == HTTPMessage::HTTP_1_1);
assertTrue (request.size() == 5);
assertTrue (request["Connection"] == "Close");
assertTrue (request["Host"] == "localhost:8000");
assertTrue (request["User-Agent"] == "Poco");
assertTrue (request.getContentType() == "text/plain");
assertTrue (request.getContentLength() == 100);
assertTrue (istr.get() == -1);
}
@@ -139,16 +139,16 @@ void HTTPRequestTest::testRead4()
std::istringstream istr(s);
HTTPRequest request;
request.read(istr);
assert (request.getMethod() == HTTPRequest::HTTP_POST);
assert (request.getURI() == "/test.cgi");
assert (request.getVersion() == HTTPMessage::HTTP_1_1);
assert (request.size() == 5);
assert (request["Connection"] == "Close");
assert (request["Host"] == "localhost:8000");
assert (request["User-Agent"] == "Poco");
assert (request.getContentType() == "text/plain");
assert (request.getContentLength() == 100);
assert (istr.get() == -1);
assertTrue (request.getMethod() == HTTPRequest::HTTP_POST);
assertTrue (request.getURI() == "/test.cgi");
assertTrue (request.getVersion() == HTTPMessage::HTTP_1_1);
assertTrue (request.size() == 5);
assertTrue (request["Connection"] == "Close");
assertTrue (request["Host"] == "localhost:8000");
assertTrue (request["User-Agent"] == "Poco");
assertTrue (request.getContentType() == "text/plain");
assertTrue (request.getContentLength() == 100);
assertTrue (istr.get() == -1);
}
@@ -208,31 +208,31 @@ void HTTPRequestTest::testCookies()
NameValueCollection cookies1;
cookies1.add("cookie1", "value1");
request1.setCookies(cookies1);
assert (request1["Cookie"] == "cookie1=value1");
assertTrue (request1["Cookie"] == "cookie1=value1");
HTTPRequest request2;
NameValueCollection cookies2;
cookies2.add("cookie2", "value2");
cookies2.add("cookie3", "value3");
request2.setCookies(cookies2);
assert (request2["Cookie"] == "cookie2=value2; cookie3=value3");
assertTrue (request2["Cookie"] == "cookie2=value2; cookie3=value3");
request1.setCookies(cookies2);
NameValueCollection cookies3;
request1.getCookies(cookies3);
assert (cookies3.size() == 3);
assert (cookies3["cookie1"] == "value1");
assert (cookies3["cookie2"] == "value2");
assert (cookies3["cookie3"] == "value3");
assertTrue (cookies3.size() == 3);
assertTrue (cookies3["cookie1"] == "value1");
assertTrue (cookies3["cookie2"] == "value2");
assertTrue (cookies3["cookie3"] == "value3");
HTTPRequest request3;
request3.add("Cookie", "cookie1=value1");
request3.add("cookie", "cookie2=value2");
NameValueCollection cookies4;
request3.getCookies(cookies4);
assert (cookies4.size() == 2);
assert (cookies4["cookie1"] == "value1");
assert (cookies4["cookie2"] == "value2");
assertTrue (cookies4.size() == 2);
assertTrue (cookies4["cookie1"] == "value1");
assertTrue (cookies4["cookie2"] == "value2");
}

80
Net/testsuite/src/HTTPResponseTest.cpp
View File

@@ -39,7 +39,7 @@ void HTTPResponseTest::testWrite1()
std::ostringstream ostr;
response.write(ostr);
std::string s = ostr.str();
assert (s == "HTTP/1.0 200 OK\r\n\r\n");
assertTrue (s == "HTTP/1.0 200 OK\r\n\r\n");
}
@@ -51,7 +51,7 @@ void HTTPResponseTest::testWrite2()
std::ostringstream ostr;
response.write(ostr);
std::string s = ostr.str();
assert (s == "HTTP/1.1 301 Moved Permanently\r\nLocation: http://www.appinf.com/index.html\r\nServer: Poco/1.0\r\n\r\n");
assertTrue (s == "HTTP/1.1 301 Moved Permanently\r\nLocation: http://www.appinf.com/index.html\r\nServer: Poco/1.0\r\n\r\n");
}
@@ -61,11 +61,11 @@ void HTTPResponseTest::testRead1()
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getStatus() == HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
assert (response.getReason() == "Internal Server Error");
assert (response.getVersion() == HTTPMessage::HTTP_1_1);
assert (response.empty());
assert (istr.get() == -1);
assertTrue (response.getStatus() == HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
assertTrue (response.getReason() == "Internal Server Error");
assertTrue (response.getVersion() == HTTPMessage::HTTP_1_1);
assertTrue (response.empty());
assertTrue (istr.get() == -1);
}
@@ -75,13 +75,13 @@ void HTTPResponseTest::testRead2()
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY);
assert (response.getReason() == "Moved Permanently");
assert (response.getVersion() == HTTPMessage::HTTP_1_0);
assert (response.size() == 2);
assert (response["Location"] == "http://www.appinf.com/index.html");
assert (response["Server"] == "Poco/1.0");
assert (istr.get() == -1);
assertTrue (response.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY);
assertTrue (response.getReason() == "Moved Permanently");
assertTrue (response.getVersion() == HTTPMessage::HTTP_1_0);
assertTrue (response.size() == 2);
assertTrue (response["Location"] == "http://www.appinf.com/index.html");
assertTrue (response["Server"] == "Poco/1.0");
assertTrue (istr.get() == -1);
}
@@ -91,12 +91,12 @@ void HTTPResponseTest::testRead3()
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getVersion() == HTTPMessage::HTTP_1_1);
assert (response.getStatus() == HTTPResponse::HTTP_OK);
assert (response.getReason() == "");
assert (response.size() == 1);
assert (response.getContentLength() == 0);
assert (istr.get() == -1);
assertTrue (response.getVersion() == HTTPMessage::HTTP_1_1);
assertTrue (response.getStatus() == HTTPResponse::HTTP_OK);
assertTrue (response.getReason() == "");
assertTrue (response.size() == 1);
assertTrue (response.getContentLength() == 0);
assertTrue (istr.get() == -1);
}
@@ -159,15 +159,15 @@ void HTTPResponseTest::testCookies()
response.addCookie(cookie1);
std::vector<HTTPCookie> cookies;
response.getCookies(cookies);
assert (cookies.size() == 1);
assert (cookie1.getVersion() == cookies[0].getVersion());
assert (cookie1.getName() == cookies[0].getName());
assert (cookie1.getValue() == cookies[0].getValue());
assert (cookie1.getComment() == cookies[0].getComment());
assert (cookie1.getDomain() == cookies[0].getDomain());
assert (cookie1.getPath() == cookies[0].getPath());
assert (cookie1.getSecure() == cookies[0].getSecure());
assert (cookie1.getMaxAge() == cookies[0].getMaxAge());
assertTrue (cookies.size() == 1);
assertTrue (cookie1.getVersion() == cookies[0].getVersion());
assertTrue (cookie1.getName() == cookies[0].getName());
assertTrue (cookie1.getValue() == cookies[0].getValue());
assertTrue (cookie1.getComment() == cookies[0].getComment());
assertTrue (cookie1.getDomain() == cookies[0].getDomain());
assertTrue (cookie1.getPath() == cookies[0].getPath());
assertTrue (cookie1.getSecure() == cookies[0].getSecure());
assertTrue (cookie1.getMaxAge() == cookies[0].getMaxAge());
HTTPCookie cookie2("cookie2", "value2");
cookie2.setVersion(1);
@@ -175,28 +175,28 @@ void HTTPResponseTest::testCookies()
cookie2.setSecure(true);
response.addCookie(cookie2);
response.getCookies(cookies);
assert (cookies.size() == 2);
assertTrue (cookies.size() == 2);
HTTPCookie cookie2a;
if (cookies[0].getName() == cookie2.getName())
cookie2a = cookies[0];
else
cookie2a = cookies[1];
assert (cookie2.getVersion() == cookie2a.getVersion());
assert (cookie2.getName() == cookie2a.getName());
assert (cookie2.getValue() == cookie2a.getValue());
assert (cookie2.getComment() == cookie2a.getComment());
assert (cookie2.getDomain() == cookie2a.getDomain());
assert (cookie2.getPath() == cookie2a.getPath());
assert (cookie2.getSecure() == cookie2a.getSecure());
assert (cookie2.getMaxAge() == cookie2a.getMaxAge());
assertTrue (cookie2.getVersion() == cookie2a.getVersion());
assertTrue (cookie2.getName() == cookie2a.getName());
assertTrue (cookie2.getValue() == cookie2a.getValue());
assertTrue (cookie2.getComment() == cookie2a.getComment());
assertTrue (cookie2.getDomain() == cookie2a.getDomain());
assertTrue (cookie2.getPath() == cookie2a.getPath());
assertTrue (cookie2.getSecure() == cookie2a.getSecure());
assertTrue (cookie2.getMaxAge() == cookie2a.getMaxAge());
HTTPResponse response2;
response2.add("Set-Cookie", "name1=value1");
response2.add("Set-cookie", "name2=value2");
cookies.clear();
response2.getCookies(cookies);
assert (cookies.size() == 2);
assert (cookies[0].getName() == "name1" && cookies[1].getName() == "name2"
assertTrue (cookies.size() == 2);
assertTrue (cookies[0].getName() == "name1" && cookies[1].getName() == "name2"
|| cookies[0].getName() == "name2" && cookies[1].getName() == "name1");
}

148
Net/testsuite/src/HTTPServerTest.cpp
View File

@@ -153,9 +153,9 @@ void HTTPServerTest::testIdentityRequest()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == body.size());
assert (response.getContentType() == "text/plain");
assert (rbody == body);
assertTrue (response.getContentLength() == body.size());
assertTrue (response.getContentType() == "text/plain");
assertTrue (rbody == body);
}
@@ -176,9 +176,9 @@ void HTTPServerTest::testPutIdentityRequest()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == body.size());
assert (response.getContentType() == "text/plain");
assert (rbody == body);
assertTrue (response.getContentLength() == body.size());
assertTrue (response.getContentType() == "text/plain");
assertTrue (rbody == body);
}
@@ -199,10 +199,10 @@ void HTTPServerTest::testChunkedRequest()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (rbody == body);
}
@@ -222,10 +222,10 @@ void HTTPServerTest::testClosedRequest()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (!response.getChunkedTransferEncoding());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (!response.getChunkedTransferEncoding());
assertTrue (rbody == body);
}
@@ -244,20 +244,20 @@ void HTTPServerTest::testIdentityRequestKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == body.size());
assert (response.getContentType() == "text/plain");
assert (response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == body.size());
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getKeepAlive());
assertTrue (rbody == body);
body.assign(1000, 'y');
request.setContentLength((int) body.length());
request.setKeepAlive(false);
cs.sendRequest(request) << body;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == body.size());
assert (response.getContentType() == "text/plain");
assert (!response.getKeepAlive());
assert (rbody == body);}
assertTrue (response.getContentLength() == body.size());
assertTrue (response.getContentType() == "text/plain");
assertTrue (!response.getKeepAlive());
assertTrue (rbody == body);}
void HTTPServerTest::testChunkedRequestKeepAlive()
@@ -275,20 +275,20 @@ void HTTPServerTest::testChunkedRequestKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (rbody == body);
body.assign(1000, 'y');
request.setKeepAlive(false);
cs.sendRequest(request) << body;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (!response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (!response.getKeepAlive());
assertTrue (rbody == body);
}
@@ -305,11 +305,11 @@ void HTTPServerTest::testClosedRequestKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (!response.getChunkedTransferEncoding());
assert (!response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (!response.getChunkedTransferEncoding());
assertTrue (!response.getKeepAlive());
assertTrue (rbody == body);
}
@@ -334,11 +334,11 @@ void HTTPServerTest::testMaxKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getKeepAlive());
assertTrue (rbody == body);
}
{
@@ -346,11 +346,11 @@ void HTTPServerTest::testMaxKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (!response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (!response.getKeepAlive());
assertTrue (rbody == body);
}
{
@@ -359,11 +359,11 @@ void HTTPServerTest::testMaxKeepAlive()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (!response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (!response.getKeepAlive());
assertTrue (rbody == body);
}
}
@@ -391,11 +391,11 @@ void HTTPServerTest::testKeepAliveTimeout()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getKeepAlive());
assertTrue (rbody == body);
}
Poco::Thread::sleep(4000);
@@ -405,11 +405,11 @@ void HTTPServerTest::testKeepAliveTimeout()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assert (response.getChunkedTransferEncoding());
assert (response.getKeepAlive());
assert (rbody == body);
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
assertTrue (response.getChunkedTransferEncoding());
assertTrue (response.getKeepAlive());
assertTrue (rbody == body);
}
}
@@ -432,9 +432,9 @@ void HTTPServerTest::test100Continue()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getContentLength() == body.size());
assert (response.getContentType() == "text/plain");
assert (rbody == body);
assertTrue (response.getContentLength() == body.size());
assertTrue (response.getContentType() == "text/plain");
assertTrue (rbody == body);
}
@@ -452,9 +452,9 @@ void HTTPServerTest::testRedirect()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getStatus() == HTTPResponse::HTTP_FOUND);
assert (response.get("Location") == "http://www.appinf.com/");
assert (rbody.empty());
assertTrue (response.getStatus() == HTTPResponse::HTTP_FOUND);
assertTrue (response.get("Location") == "http://www.appinf.com/");
assertTrue (rbody.empty());
}
@@ -472,9 +472,9 @@ void HTTPServerTest::testAuth()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED);
assert (response.get("WWW-Authenticate") == "Basic realm=\"/auth\"");
assert (rbody.empty());
assertTrue (response.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED);
assertTrue (response.get("WWW-Authenticate") == "Basic realm=\"/auth\"");
assertTrue (rbody.empty());
}
@@ -492,8 +492,8 @@ void HTTPServerTest::testNotImpl()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getStatus() == HTTPResponse::HTTP_NOT_IMPLEMENTED);
assert (rbody.empty());
assertTrue (response.getStatus() == HTTPResponse::HTTP_NOT_IMPLEMENTED);
assertTrue (rbody.empty());
}
@@ -511,8 +511,8 @@ void HTTPServerTest::testBuffer()
HTTPResponse response;
std::string rbody;
cs.receiveResponse(response) >> rbody;
assert (response.getStatus() == HTTPResponse::HTTP_OK);
assert (rbody == "xxxxxxxxxx");
assertTrue (response.getStatus() == HTTPResponse::HTTP_OK);
assertTrue (rbody == "xxxxxxxxxx");
}

8
Net/testsuite/src/HTTPStreamFactoryTest.cpp
View File

@@ -51,7 +51,7 @@ void HTTPStreamFactoryTest::testNoRedirect()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
}
@@ -68,7 +68,7 @@ void HTTPStreamFactoryTest::testEmptyPath()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPTestServer::SMALL_BODY);
assertTrue (ostr.str() == HTTPTestServer::SMALL_BODY);
}
@@ -86,7 +86,7 @@ void HTTPStreamFactoryTest::testRedirect()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
}
@@ -102,7 +102,7 @@ void HTTPStreamFactoryTest::testProxy()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPTestServer::LARGE_BODY);
}

28
Net/testsuite/src/ICMPClientTest.cpp
View File

@@ -45,23 +45,23 @@ ICMPClientTest::~ICMPClientTest()
void ICMPClientTest::testPing()
{
assert(ICMPClient::pingIPv4("127.0.0.1") > 0);
assertTrue (ICMPClient::pingIPv4("127.0.0.1") > 0);
Poco::Net::ICMPClient icmpClient(IPAddress::IPv4);
registerDelegates(icmpClient);
assert(icmpClient.ping("127.0.0.1") > 0);
assertTrue (icmpClient.ping("127.0.0.1") > 0);
#if POCO_OS == POCO_OS_ANDROID
assert(icmpClient.ping("10.0.2.15", 4) > 0);
assert(icmpClient.ping("10.0.2.2", 4) > 0);
assertTrue (icmpClient.ping("10.0.2.15", 4) > 0);
assertTrue (icmpClient.ping("10.0.2.2", 4) > 0);
#else
assert(icmpClient.ping("www.appinf.com", 4) > 0);
assertTrue (icmpClient.ping("www.appinf.com", 4) > 0);
// warning: may fail depending on the existence of the addresses at test site
// if so, adjust accordingly (i.e. specify non-existent or unreachable IP addresses)
assert(0 == icmpClient.ping("192.168.243.1"));
assert(0 == icmpClient.ping("10.11.12.13"));
assertTrue (0 == icmpClient.ping("192.168.243.1"));
assertTrue (0 == icmpClient.ping("10.11.12.13"));
#endif
unregisterDelegates(icmpClient);
@@ -70,23 +70,23 @@ void ICMPClientTest::testPing()
void ICMPClientTest::testBigPing()
{
assert(ICMPClient::pingIPv4("127.0.0.1", 1, 96) > 0);
assertTrue (ICMPClient::pingIPv4("127.0.0.1", 1, 96) > 0);
Poco::Net::ICMPClient icmpClient(IPAddress::IPv4, 96);
registerDelegates(icmpClient);
assert(icmpClient.ping("127.0.0.1", 1) > 0);
assertTrue (icmpClient.ping("127.0.0.1", 1) > 0);
#if POCO_OS == POCO_OS_ANDROID
assert(icmpClient.ping("10.0.2.15", 4) > 0);
assert(icmpClient.ping("10.0.2.2", 4) > 0);
assertTrue (icmpClient.ping("10.0.2.15", 4) > 0);
assertTrue (icmpClient.ping("10.0.2.2", 4) > 0);
#else
assert(icmpClient.ping("www.appinf.com", 4) > 0);
assertTrue (icmpClient.ping("www.appinf.com", 4) > 0);
// warning: may fail depending on the existence of the addresses at test site
// if so, adjust accordingly (i.e. specify non-existent or unreachable IP addresses)
assert(0 == icmpClient.ping("192.168.243.1"));
assert(0 == icmpClient.ping("10.11.12.13"));
assertTrue (0 == icmpClient.ping("192.168.243.1"));
assertTrue (0 == icmpClient.ping("10.11.12.13"));
#endif
unregisterDelegates(icmpClient);

2
Net/testsuite/src/ICMPSocketTest.cpp
View File

@@ -67,7 +67,7 @@ void ICMPSocketTest::testSendToReceiveFrom()
ss.sendTo(sa);
ss.receiveFrom(sa);
assert(sr.host().toString() == sa.host().toString());
assertTrue (sr.host().toString() == sa.host().toString());
ss.close();
}

780
Net/testsuite/src/IPAddressTest.cpp
View File

@@ -32,24 +32,24 @@ IPAddressTest::~IPAddressTest()
void IPAddressTest::testStringConv()
{
IPAddress ia1("127.0.0.1");
assert (ia1.family() == IPAddress::IPv4);
assert (ia1.toString() == "127.0.0.1");
assertTrue (ia1.family() == IPAddress::IPv4);
assertTrue (ia1.toString() == "127.0.0.1");
IPAddress ia2("192.168.1.120");
assert (ia2.family() == IPAddress::IPv4);
assert (ia2.toString() == "192.168.1.120");
assertTrue (ia2.family() == IPAddress::IPv4);
assertTrue (ia2.toString() == "192.168.1.120");
IPAddress ia3("255.255.255.255");
assert (ia3.family() == IPAddress::IPv4);
assert (ia3.toString() == "255.255.255.255");
assertTrue (ia3.family() == IPAddress::IPv4);
assertTrue (ia3.toString() == "255.255.255.255");
IPAddress ia4("0.0.0.0");
assert (ia4.family() == IPAddress::IPv4);
assert (ia4.toString() == "0.0.0.0");
assertTrue (ia4.family() == IPAddress::IPv4);
assertTrue (ia4.toString() == "0.0.0.0");
IPAddress ia5(24, IPAddress::IPv4);
assert (ia5.family() == IPAddress::IPv4);
assert (ia5.toString() == "255.255.255.0");
assertTrue (ia5.family() == IPAddress::IPv4);
assertTrue (ia5.toString() == "255.255.255.0");
}
@@ -57,36 +57,36 @@ void IPAddressTest::testStringConv6()
{
#ifdef POCO_HAVE_IPv6
IPAddress ia0("::1");
assert (ia0.family() == IPAddress::IPv6);
assert (ia0.toString() == "::1");
assertTrue (ia0.family() == IPAddress::IPv6);
assertTrue (ia0.toString() == "::1");
IPAddress ia1("1080:0:0:0:8:600:200a:425c");
assert (ia1.family() == IPAddress::IPv6);
assert (ia1.toString() == "1080::8:600:200a:425c");
assertTrue (ia1.family() == IPAddress::IPv6);
assertTrue (ia1.toString() == "1080::8:600:200a:425c");
IPAddress ia2("1080::8:600:200A:425C");
assert (ia2.family() == IPAddress::IPv6);
assert (ia2.toString() == "1080::8:600:200a:425c");
assertTrue (ia2.family() == IPAddress::IPv6);
assertTrue (ia2.toString() == "1080::8:600:200a:425c");
IPAddress ia3("::192.168.1.120");
assert (ia3.family() == IPAddress::IPv6);
assert (ia3.toString() == "::192.168.1.120");
assertTrue (ia3.family() == IPAddress::IPv6);
assertTrue (ia3.toString() == "::192.168.1.120");
IPAddress ia4("::ffff:192.168.1.120");
assert (ia4.family() == IPAddress::IPv6);
assert (ia4.toString() == "::ffff:192.168.1.120");
assertTrue (ia4.family() == IPAddress::IPv6);
assertTrue (ia4.toString() == "::ffff:192.168.1.120");
IPAddress ia5(64, IPAddress::IPv6);
assert (ia5.family() == IPAddress::IPv6);
assert (ia5.toString() == "ffff:ffff:ffff:ffff::");
assertTrue (ia5.family() == IPAddress::IPv6);
assertTrue (ia5.toString() == "ffff:ffff:ffff:ffff::");
IPAddress ia6(32, IPAddress::IPv6);
assert (ia6.family() == IPAddress::IPv6);
assert (ia6.toString() == "ffff:ffff::");
assertTrue (ia6.family() == IPAddress::IPv6);
assertTrue (ia6.toString() == "ffff:ffff::");
IPAddress ia7("::");
assert (ia7.family() == IPAddress::IPv6);
assert (ia7.toString() == "::");
assertTrue (ia7.family() == IPAddress::IPv6);
assertTrue (ia7.toString() == "::");
#endif
}
@@ -94,9 +94,9 @@ void IPAddressTest::testStringConv6()
void IPAddressTest::testParse()
{
IPAddress ip;
assert (IPAddress::tryParse("192.168.1.120", ip));
assertTrue (IPAddress::tryParse("192.168.1.120", ip));
assert (!IPAddress::tryParse("192.168.1.280", ip));
assertTrue (!IPAddress::tryParse("192.168.1.280", ip));
ip = IPAddress::parse("192.168.1.120");
try
@@ -113,203 +113,203 @@ void IPAddressTest::testParse()
void IPAddressTest::testClassification()
{
IPAddress ip1("0.0.0.0"); // wildcard
assert (ip1.isWildcard());
assert (!ip1.isBroadcast());
assert (!ip1.isLoopback());
assert (!ip1.isMulticast());
assert (!ip1.isUnicast());
assert (!ip1.isLinkLocal());
assert (!ip1.isSiteLocal());
assert (!ip1.isWellKnownMC());
assert (!ip1.isNodeLocalMC());
assert (!ip1.isLinkLocalMC());
assert (!ip1.isSiteLocalMC());
assert (!ip1.isOrgLocalMC());
assert (!ip1.isGlobalMC());
assertTrue (ip1.isWildcard());
assertTrue (!ip1.isBroadcast());
assertTrue (!ip1.isLoopback());
assertTrue (!ip1.isMulticast());
assertTrue (!ip1.isUnicast());
assertTrue (!ip1.isLinkLocal());
assertTrue (!ip1.isSiteLocal());
assertTrue (!ip1.isWellKnownMC());
assertTrue (!ip1.isNodeLocalMC());
assertTrue (!ip1.isLinkLocalMC());
assertTrue (!ip1.isSiteLocalMC());
assertTrue (!ip1.isOrgLocalMC());
assertTrue (!ip1.isGlobalMC());
IPAddress ip2("255.255.255.255"); // broadcast
assert (!ip2.isWildcard());
assert (ip2.isBroadcast());
assert (!ip2.isLoopback());
assert (!ip2.isMulticast());
assert (!ip2.isUnicast());
assert (!ip2.isLinkLocal());
assert (!ip2.isSiteLocal());
assert (!ip2.isWellKnownMC());
assert (!ip2.isNodeLocalMC());
assert (!ip2.isLinkLocalMC());
assert (!ip2.isSiteLocalMC());
assert (!ip2.isOrgLocalMC());
assert (!ip2.isGlobalMC());
assertTrue (!ip2.isWildcard());
assertTrue (ip2.isBroadcast());
assertTrue (!ip2.isLoopback());
assertTrue (!ip2.isMulticast());
assertTrue (!ip2.isUnicast());
assertTrue (!ip2.isLinkLocal());
assertTrue (!ip2.isSiteLocal());
assertTrue (!ip2.isWellKnownMC());
assertTrue (!ip2.isNodeLocalMC());
assertTrue (!ip2.isLinkLocalMC());
assertTrue (!ip2.isSiteLocalMC());
assertTrue (!ip2.isOrgLocalMC());
assertTrue (!ip2.isGlobalMC());
IPAddress ip3("127.0.0.1"); // loopback
assert (!ip3.isWildcard());
assert (!ip3.isBroadcast());
assert (ip3.isLoopback());
assert (!ip3.isMulticast());
assert (ip3.isUnicast());
assert (!ip3.isLinkLocal());
assert (!ip3.isSiteLocal());
assert (!ip3.isWellKnownMC());
assert (!ip3.isNodeLocalMC());
assert (!ip3.isLinkLocalMC());
assert (!ip3.isSiteLocalMC());
assert (!ip3.isOrgLocalMC());
assert (!ip3.isGlobalMC());
assertTrue (!ip3.isWildcard());
assertTrue (!ip3.isBroadcast());
assertTrue (ip3.isLoopback());
assertTrue (!ip3.isMulticast());
assertTrue (ip3.isUnicast());
assertTrue (!ip3.isLinkLocal());
assertTrue (!ip3.isSiteLocal());
assertTrue (!ip3.isWellKnownMC());
assertTrue (!ip3.isNodeLocalMC());
assertTrue (!ip3.isLinkLocalMC());
assertTrue (!ip3.isSiteLocalMC());
assertTrue (!ip3.isOrgLocalMC());
assertTrue (!ip3.isGlobalMC());
IPAddress ip4("80.122.195.86"); // unicast
assert (!ip4.isWildcard());
assert (!ip4.isBroadcast());
assert (!ip4.isLoopback());
assert (!ip4.isMulticast());
assert (ip4.isUnicast());
assert (!ip4.isLinkLocal());
assert (!ip4.isSiteLocal());
assert (!ip4.isWellKnownMC());
assert (!ip4.isNodeLocalMC());
assert (!ip4.isLinkLocalMC());
assert (!ip4.isSiteLocalMC());
assert (!ip4.isOrgLocalMC());
assert (!ip4.isGlobalMC());
assertTrue (!ip4.isWildcard());
assertTrue (!ip4.isBroadcast());
assertTrue (!ip4.isLoopback());
assertTrue (!ip4.isMulticast());
assertTrue (ip4.isUnicast());
assertTrue (!ip4.isLinkLocal());
assertTrue (!ip4.isSiteLocal());
assertTrue (!ip4.isWellKnownMC());
assertTrue (!ip4.isNodeLocalMC());
assertTrue (!ip4.isLinkLocalMC());
assertTrue (!ip4.isSiteLocalMC());
assertTrue (!ip4.isOrgLocalMC());
assertTrue (!ip4.isGlobalMC());
IPAddress ip5("169.254.1.20"); // link local unicast
assert (!ip5.isWildcard());
assert (!ip5.isBroadcast());
assert (!ip5.isLoopback());
assert (!ip5.isMulticast());
assert (ip5.isUnicast());
assert (ip5.isLinkLocal());
assert (!ip5.isSiteLocal());
assert (!ip5.isWellKnownMC());
assert (!ip5.isNodeLocalMC());
assert (!ip5.isLinkLocalMC());
assert (!ip5.isSiteLocalMC());
assert (!ip5.isOrgLocalMC());
assert (!ip5.isGlobalMC());
assertTrue (!ip5.isWildcard());
assertTrue (!ip5.isBroadcast());
assertTrue (!ip5.isLoopback());
assertTrue (!ip5.isMulticast());
assertTrue (ip5.isUnicast());
assertTrue (ip5.isLinkLocal());
assertTrue (!ip5.isSiteLocal());
assertTrue (!ip5.isWellKnownMC());
assertTrue (!ip5.isNodeLocalMC());
assertTrue (!ip5.isLinkLocalMC());
assertTrue (!ip5.isSiteLocalMC());
assertTrue (!ip5.isOrgLocalMC());
assertTrue (!ip5.isGlobalMC());
IPAddress ip6("192.168.1.120"); // site local unicast
assert (!ip6.isWildcard());
assert (!ip6.isBroadcast());
assert (!ip6.isLoopback());
assert (!ip6.isMulticast());
assert (ip6.isUnicast());
assert (!ip6.isLinkLocal());
assert (ip6.isSiteLocal());
assert (!ip6.isWellKnownMC());
assert (!ip6.isNodeLocalMC());
assert (!ip6.isLinkLocalMC());
assert (!ip6.isSiteLocalMC());
assert (!ip6.isOrgLocalMC());
assert (!ip6.isGlobalMC());
assertTrue (!ip6.isWildcard());
assertTrue (!ip6.isBroadcast());
assertTrue (!ip6.isLoopback());
assertTrue (!ip6.isMulticast());
assertTrue (ip6.isUnicast());
assertTrue (!ip6.isLinkLocal());
assertTrue (ip6.isSiteLocal());
assertTrue (!ip6.isWellKnownMC());
assertTrue (!ip6.isNodeLocalMC());
assertTrue (!ip6.isLinkLocalMC());
assertTrue (!ip6.isSiteLocalMC());
assertTrue (!ip6.isOrgLocalMC());
assertTrue (!ip6.isGlobalMC());
IPAddress ip7("10.0.0.138"); // site local unicast
assert (!ip7.isWildcard());
assert (!ip7.isBroadcast());
assert (!ip7.isLoopback());
assert (!ip7.isMulticast());
assert (ip7.isUnicast());
assert (!ip7.isLinkLocal());
assert (ip7.isSiteLocal());
assert (!ip7.isWellKnownMC());
assert (!ip7.isNodeLocalMC());
assert (!ip7.isLinkLocalMC());
assert (!ip7.isSiteLocalMC());
assert (!ip7.isOrgLocalMC());
assert (!ip7.isGlobalMC());
assertTrue (!ip7.isWildcard());
assertTrue (!ip7.isBroadcast());
assertTrue (!ip7.isLoopback());
assertTrue (!ip7.isMulticast());
assertTrue (ip7.isUnicast());
assertTrue (!ip7.isLinkLocal());
assertTrue (ip7.isSiteLocal());
assertTrue (!ip7.isWellKnownMC());
assertTrue (!ip7.isNodeLocalMC());
assertTrue (!ip7.isLinkLocalMC());
assertTrue (!ip7.isSiteLocalMC());
assertTrue (!ip7.isOrgLocalMC());
assertTrue (!ip7.isGlobalMC());
IPAddress ip8("172.18.1.200"); // site local unicast
assert (!ip8.isWildcard());
assert (!ip8.isBroadcast());
assert (!ip8.isLoopback());
assert (!ip8.isMulticast());
assert (ip8.isUnicast());
assert (!ip8.isLinkLocal());
assert (ip8.isSiteLocal());
assert (!ip8.isWellKnownMC());
assert (!ip8.isNodeLocalMC());
assert (!ip8.isLinkLocalMC());
assert (!ip8.isSiteLocalMC());
assert (!ip8.isOrgLocalMC());
assert (!ip8.isGlobalMC());
assertTrue (!ip8.isWildcard());
assertTrue (!ip8.isBroadcast());
assertTrue (!ip8.isLoopback());
assertTrue (!ip8.isMulticast());
assertTrue (ip8.isUnicast());
assertTrue (!ip8.isLinkLocal());
assertTrue (ip8.isSiteLocal());
assertTrue (!ip8.isWellKnownMC());
assertTrue (!ip8.isNodeLocalMC());
assertTrue (!ip8.isLinkLocalMC());
assertTrue (!ip8.isSiteLocalMC());
assertTrue (!ip8.isOrgLocalMC());
assertTrue (!ip8.isGlobalMC());
}
void IPAddressTest::testMCClassification()
{
IPAddress ip1("224.0.0.100"); // well-known multicast
assert (!ip1.isWildcard());
assert (!ip1.isBroadcast());
assert (!ip1.isLoopback());
assert (ip1.isMulticast());
assert (!ip1.isUnicast());
assert (!ip1.isLinkLocal());
assert (!ip1.isSiteLocal());
assert (ip1.isWellKnownMC());
assert (!ip1.isNodeLocalMC());
assert (ip1.isLinkLocalMC()); // well known are in the range of link local
assert (!ip1.isSiteLocalMC());
assert (!ip1.isOrgLocalMC());
assert (!ip1.isGlobalMC());
assertTrue (!ip1.isWildcard());
assertTrue (!ip1.isBroadcast());
assertTrue (!ip1.isLoopback());
assertTrue (ip1.isMulticast());
assertTrue (!ip1.isUnicast());
assertTrue (!ip1.isLinkLocal());
assertTrue (!ip1.isSiteLocal());
assertTrue (ip1.isWellKnownMC());
assertTrue (!ip1.isNodeLocalMC());
assertTrue (ip1.isLinkLocalMC()); // well known are in the range of link local
assertTrue (!ip1.isSiteLocalMC());
assertTrue (!ip1.isOrgLocalMC());
assertTrue (!ip1.isGlobalMC());
IPAddress ip2("224.1.0.100"); // link local unicast
assert (!ip2.isWildcard());
assert (!ip2.isBroadcast());
assert (!ip2.isLoopback());
assert (ip2.isMulticast());
assert (!ip2.isUnicast());
assert (!ip2.isLinkLocal());
assert (!ip2.isSiteLocal());
assert (!ip2.isWellKnownMC());
assert (!ip2.isNodeLocalMC());
assert (ip2.isLinkLocalMC());
assert (!ip2.isSiteLocalMC());
assert (!ip2.isOrgLocalMC());
assert (ip2.isGlobalMC()); // link local fall in the range of global
assertTrue (!ip2.isWildcard());
assertTrue (!ip2.isBroadcast());
assertTrue (!ip2.isLoopback());
assertTrue (ip2.isMulticast());
assertTrue (!ip2.isUnicast());
assertTrue (!ip2.isLinkLocal());
assertTrue (!ip2.isSiteLocal());
assertTrue (!ip2.isWellKnownMC());
assertTrue (!ip2.isNodeLocalMC());
assertTrue (ip2.isLinkLocalMC());
assertTrue (!ip2.isSiteLocalMC());
assertTrue (!ip2.isOrgLocalMC());
assertTrue (ip2.isGlobalMC()); // link local fall in the range of global
IPAddress ip3("239.255.0.100"); // site local unicast
assert (!ip3.isWildcard());
assert (!ip3.isBroadcast());
assert (!ip3.isLoopback());
assert (ip3.isMulticast());
assert (!ip3.isUnicast());
assert (!ip3.isLinkLocal());
assert (!ip3.isSiteLocal());
assert (!ip3.isWellKnownMC());
assert (!ip3.isNodeLocalMC());
assert (!ip3.isLinkLocalMC());
assert (ip3.isSiteLocalMC());
assert (!ip3.isOrgLocalMC());
assert (!ip3.isGlobalMC());
assertTrue (!ip3.isWildcard());
assertTrue (!ip3.isBroadcast());
assertTrue (!ip3.isLoopback());
assertTrue (ip3.isMulticast());
assertTrue (!ip3.isUnicast());
assertTrue (!ip3.isLinkLocal());
assertTrue (!ip3.isSiteLocal());
assertTrue (!ip3.isWellKnownMC());
assertTrue (!ip3.isNodeLocalMC());
assertTrue (!ip3.isLinkLocalMC());
assertTrue (ip3.isSiteLocalMC());
assertTrue (!ip3.isOrgLocalMC());
assertTrue (!ip3.isGlobalMC());
IPAddress ip4("239.192.0.100"); // org local unicast
assert (!ip4.isWildcard());
assert (!ip4.isBroadcast());
assert (!ip4.isLoopback());
assert (ip4.isMulticast());
assert (!ip4.isUnicast());
assert (!ip4.isLinkLocal());
assert (!ip4.isSiteLocal());
assert (!ip4.isWellKnownMC());
assert (!ip4.isNodeLocalMC());
assert (!ip4.isLinkLocalMC());
assert (!ip4.isSiteLocalMC());
assert (ip4.isOrgLocalMC());
assert (!ip4.isGlobalMC());
assertTrue (!ip4.isWildcard());
assertTrue (!ip4.isBroadcast());
assertTrue (!ip4.isLoopback());
assertTrue (ip4.isMulticast());
assertTrue (!ip4.isUnicast());
assertTrue (!ip4.isLinkLocal());
assertTrue (!ip4.isSiteLocal());
assertTrue (!ip4.isWellKnownMC());
assertTrue (!ip4.isNodeLocalMC());
assertTrue (!ip4.isLinkLocalMC());
assertTrue (!ip4.isSiteLocalMC());
assertTrue (ip4.isOrgLocalMC());
assertTrue (!ip4.isGlobalMC());
IPAddress ip5("224.2.127.254"); // global unicast
assert (!ip5.isWildcard());
assert (!ip5.isBroadcast());
assert (!ip5.isLoopback());
assert (ip5.isMulticast());
assert (!ip5.isUnicast());
assert (!ip5.isLinkLocal());
assert (!ip5.isSiteLocal());
assert (!ip5.isWellKnownMC());
assert (!ip5.isNodeLocalMC());
assert (ip5.isLinkLocalMC()); // link local fall in the range of global
assert (!ip5.isSiteLocalMC());
assert (!ip5.isOrgLocalMC());
assert (ip5.isGlobalMC());
assertTrue (!ip5.isWildcard());
assertTrue (!ip5.isBroadcast());
assertTrue (!ip5.isLoopback());
assertTrue (ip5.isMulticast());
assertTrue (!ip5.isUnicast());
assertTrue (!ip5.isLinkLocal());
assertTrue (!ip5.isSiteLocal());
assertTrue (!ip5.isWellKnownMC());
assertTrue (!ip5.isNodeLocalMC());
assertTrue (ip5.isLinkLocalMC()); // link local fall in the range of global
assertTrue (!ip5.isSiteLocalMC());
assertTrue (!ip5.isOrgLocalMC());
assertTrue (ip5.isGlobalMC());
}
@@ -317,109 +317,109 @@ void IPAddressTest::testClassification6()
{
#ifdef POCO_HAVE_IPv6
IPAddress ip1("::"); // wildcard
assert (ip1.isWildcard());
assert (!ip1.isBroadcast());
assert (!ip1.isLoopback());
assert (!ip1.isMulticast());
assert (!ip1.isUnicast());
assert (!ip1.isLinkLocal());
assert (!ip1.isSiteLocal());
assert (!ip1.isWellKnownMC());
assert (!ip1.isNodeLocalMC());
assert (!ip1.isLinkLocalMC());
assert (!ip1.isSiteLocalMC());
assert (!ip1.isOrgLocalMC());
assert (!ip1.isGlobalMC());
assertTrue (ip1.isWildcard());
assertTrue (!ip1.isBroadcast());
assertTrue (!ip1.isLoopback());
assertTrue (!ip1.isMulticast());
assertTrue (!ip1.isUnicast());
assertTrue (!ip1.isLinkLocal());
assertTrue (!ip1.isSiteLocal());
assertTrue (!ip1.isWellKnownMC());
assertTrue (!ip1.isNodeLocalMC());
assertTrue (!ip1.isLinkLocalMC());
assertTrue (!ip1.isSiteLocalMC());
assertTrue (!ip1.isOrgLocalMC());
assertTrue (!ip1.isGlobalMC());
IPAddress ip3("::1"); // loopback
assert (!ip3.isWildcard());
assert (!ip3.isBroadcast());
assert (ip3.isLoopback());
assert (!ip3.isMulticast());
assert (ip3.isUnicast());
assert (!ip3.isLinkLocal());
assert (!ip3.isSiteLocal());
assert (!ip3.isWellKnownMC());
assert (!ip3.isNodeLocalMC());
assert (!ip3.isLinkLocalMC());
assert (!ip3.isSiteLocalMC());
assert (!ip3.isOrgLocalMC());
assert (!ip3.isGlobalMC());
assertTrue (!ip3.isWildcard());
assertTrue (!ip3.isBroadcast());
assertTrue (ip3.isLoopback());
assertTrue (!ip3.isMulticast());
assertTrue (ip3.isUnicast());
assertTrue (!ip3.isLinkLocal());
assertTrue (!ip3.isSiteLocal());
assertTrue (!ip3.isWellKnownMC());
assertTrue (!ip3.isNodeLocalMC());
assertTrue (!ip3.isLinkLocalMC());
assertTrue (!ip3.isSiteLocalMC());
assertTrue (!ip3.isOrgLocalMC());
assertTrue (!ip3.isGlobalMC());
IPAddress ip4("2001:0db8:85a3:0000:0000:8a2e:0370:7334"); // unicast
assert (!ip4.isWildcard());
assert (!ip4.isBroadcast());
assert (!ip4.isLoopback());
assert (!ip4.isMulticast());
assert (ip4.isUnicast());
assert (!ip4.isLinkLocal());
assert (!ip4.isSiteLocal());
assert (!ip4.isWellKnownMC());
assert (!ip4.isNodeLocalMC());
assert (!ip4.isLinkLocalMC());
assert (!ip4.isSiteLocalMC());
assert (!ip4.isOrgLocalMC());
assert (!ip4.isGlobalMC());
assertTrue (!ip4.isWildcard());
assertTrue (!ip4.isBroadcast());
assertTrue (!ip4.isLoopback());
assertTrue (!ip4.isMulticast());
assertTrue (ip4.isUnicast());
assertTrue (!ip4.isLinkLocal());
assertTrue (!ip4.isSiteLocal());
assertTrue (!ip4.isWellKnownMC());
assertTrue (!ip4.isNodeLocalMC());
assertTrue (!ip4.isLinkLocalMC());
assertTrue (!ip4.isSiteLocalMC());
assertTrue (!ip4.isOrgLocalMC());
assertTrue (!ip4.isGlobalMC());
IPAddress ip5("fe80::21f:5bff:fec6:6707"); // link local unicast
assert (!ip5.isWildcard());
assert (!ip5.isBroadcast());
assert (!ip5.isLoopback());
assert (!ip5.isMulticast());
assert (ip5.isUnicast());
assert (ip5.isLinkLocal());
assert (!ip5.isSiteLocal());
assert (!ip5.isWellKnownMC());
assert (!ip5.isNodeLocalMC());
assert (!ip5.isLinkLocalMC());
assert (!ip5.isSiteLocalMC());
assert (!ip5.isOrgLocalMC());
assert (!ip5.isGlobalMC());
assertTrue (!ip5.isWildcard());
assertTrue (!ip5.isBroadcast());
assertTrue (!ip5.isLoopback());
assertTrue (!ip5.isMulticast());
assertTrue (ip5.isUnicast());
assertTrue (ip5.isLinkLocal());
assertTrue (!ip5.isSiteLocal());
assertTrue (!ip5.isWellKnownMC());
assertTrue (!ip5.isNodeLocalMC());
assertTrue (!ip5.isLinkLocalMC());
assertTrue (!ip5.isSiteLocalMC());
assertTrue (!ip5.isOrgLocalMC());
assertTrue (!ip5.isGlobalMC());
IPAddress ip10("fe80::12"); // link local unicast
assert (!ip10.isWildcard());
assert (!ip10.isBroadcast());
assert (!ip10.isLoopback());
assert (!ip10.isMulticast());
assert (ip10.isUnicast());
assert (ip10.isLinkLocal());
assert (!ip10.isSiteLocal());
assert (!ip10.isWellKnownMC());
assert (!ip10.isNodeLocalMC());
assert (!ip10.isLinkLocalMC());
assert (!ip10.isSiteLocalMC());
assert (!ip10.isOrgLocalMC());
assert (!ip10.isGlobalMC());
assertTrue (!ip10.isWildcard());
assertTrue (!ip10.isBroadcast());
assertTrue (!ip10.isLoopback());
assertTrue (!ip10.isMulticast());
assertTrue (ip10.isUnicast());
assertTrue (ip10.isLinkLocal());
assertTrue (!ip10.isSiteLocal());
assertTrue (!ip10.isWellKnownMC());
assertTrue (!ip10.isNodeLocalMC());
assertTrue (!ip10.isLinkLocalMC());
assertTrue (!ip10.isSiteLocalMC());
assertTrue (!ip10.isOrgLocalMC());
assertTrue (!ip10.isGlobalMC());
IPAddress ip6("fec0::21f:5bff:fec6:6707"); // site local unicast (RFC 4291)
assert (!ip6.isWildcard());
assert (!ip6.isBroadcast());
assert (!ip6.isLoopback());
assert (!ip6.isMulticast());
assert (ip6.isUnicast());
assert (!ip6.isLinkLocal());
assert (ip6.isSiteLocal());
assert (!ip6.isWellKnownMC());
assert (!ip6.isNodeLocalMC());
assert (!ip6.isLinkLocalMC());
assert (!ip6.isSiteLocalMC());
assert (!ip6.isOrgLocalMC());
assert (!ip6.isGlobalMC());
assertTrue (!ip6.isWildcard());
assertTrue (!ip6.isBroadcast());
assertTrue (!ip6.isLoopback());
assertTrue (!ip6.isMulticast());
assertTrue (ip6.isUnicast());
assertTrue (!ip6.isLinkLocal());
assertTrue (ip6.isSiteLocal());
assertTrue (!ip6.isWellKnownMC());
assertTrue (!ip6.isNodeLocalMC());
assertTrue (!ip6.isLinkLocalMC());
assertTrue (!ip6.isSiteLocalMC());
assertTrue (!ip6.isOrgLocalMC());
assertTrue (!ip6.isGlobalMC());
IPAddress ip7("fc00::21f:5bff:fec6:6707"); // site local unicast (RFC 4193)
assert (!ip7.isWildcard());
assert (!ip7.isBroadcast());
assert (!ip7.isLoopback());
assert (!ip7.isMulticast());
assert (ip7.isUnicast());
assert (!ip7.isLinkLocal());
assert (ip7.isSiteLocal());
assert (!ip7.isWellKnownMC());
assert (!ip7.isNodeLocalMC());
assert (!ip7.isLinkLocalMC());
assert (!ip7.isSiteLocalMC());
assert (!ip7.isOrgLocalMC());
assert (!ip7.isGlobalMC());
assertTrue (!ip7.isWildcard());
assertTrue (!ip7.isBroadcast());
assertTrue (!ip7.isLoopback());
assertTrue (!ip7.isMulticast());
assertTrue (ip7.isUnicast());
assertTrue (!ip7.isLinkLocal());
assertTrue (ip7.isSiteLocal());
assertTrue (!ip7.isWellKnownMC());
assertTrue (!ip7.isNodeLocalMC());
assertTrue (!ip7.isLinkLocalMC());
assertTrue (!ip7.isSiteLocalMC());
assertTrue (!ip7.isOrgLocalMC());
assertTrue (!ip7.isGlobalMC());
#endif
}
@@ -428,79 +428,79 @@ void IPAddressTest::testMCClassification6()
{
#ifdef POCO_HAVE_IPv6
IPAddress ip1("ff02:0:0:0:0:0:0:c"); // well-known link-local multicast
assert (!ip1.isWildcard());
assert (!ip1.isBroadcast());
assert (!ip1.isLoopback());
assert (ip1.isMulticast());
assert (!ip1.isUnicast());
assert (!ip1.isLinkLocal());
assert (!ip1.isSiteLocal());
assert (ip1.isWellKnownMC());
assert (!ip1.isNodeLocalMC());
assert (ip1.isLinkLocalMC());
assert (!ip1.isSiteLocalMC());
assert (!ip1.isOrgLocalMC());
assert (!ip1.isGlobalMC());
assertTrue (!ip1.isWildcard());
assertTrue (!ip1.isBroadcast());
assertTrue (!ip1.isLoopback());
assertTrue (ip1.isMulticast());
assertTrue (!ip1.isUnicast());
assertTrue (!ip1.isLinkLocal());
assertTrue (!ip1.isSiteLocal());
assertTrue (ip1.isWellKnownMC());
assertTrue (!ip1.isNodeLocalMC());
assertTrue (ip1.isLinkLocalMC());
assertTrue (!ip1.isSiteLocalMC());
assertTrue (!ip1.isOrgLocalMC());
assertTrue (!ip1.isGlobalMC());
IPAddress ip2("ff01:0:0:0:0:0:0:FB"); // node-local unicast
assert (!ip2.isWildcard());
assert (!ip2.isBroadcast());
assert (!ip2.isLoopback());
assert (ip2.isMulticast());
assert (!ip2.isUnicast());
assert (!ip2.isLinkLocal());
assert (!ip2.isSiteLocal());
assert (ip2.isWellKnownMC());
assert (ip2.isNodeLocalMC());
assert (!ip2.isLinkLocalMC());
assert (!ip2.isSiteLocalMC());
assert (!ip2.isOrgLocalMC());
assert (!ip2.isGlobalMC());
assertTrue (!ip2.isWildcard());
assertTrue (!ip2.isBroadcast());
assertTrue (!ip2.isLoopback());
assertTrue (ip2.isMulticast());
assertTrue (!ip2.isUnicast());
assertTrue (!ip2.isLinkLocal());
assertTrue (!ip2.isSiteLocal());
assertTrue (ip2.isWellKnownMC());
assertTrue (ip2.isNodeLocalMC());
assertTrue (!ip2.isLinkLocalMC());
assertTrue (!ip2.isSiteLocalMC());
assertTrue (!ip2.isOrgLocalMC());
assertTrue (!ip2.isGlobalMC());
IPAddress ip3("ff05:0:0:0:0:0:0:FB"); // site local unicast
assert (!ip3.isWildcard());
assert (!ip3.isBroadcast());
assert (!ip3.isLoopback());
assert (ip3.isMulticast());
assert (!ip3.isUnicast());
assert (!ip3.isLinkLocal());
assert (!ip3.isSiteLocal());
assert (ip3.isWellKnownMC());
assert (!ip3.isNodeLocalMC());
assert (!ip3.isLinkLocalMC());
assert (ip3.isSiteLocalMC());
assert (!ip3.isOrgLocalMC());
assert (!ip3.isGlobalMC());
assertTrue (!ip3.isWildcard());
assertTrue (!ip3.isBroadcast());
assertTrue (!ip3.isLoopback());
assertTrue (ip3.isMulticast());
assertTrue (!ip3.isUnicast());
assertTrue (!ip3.isLinkLocal());
assertTrue (!ip3.isSiteLocal());
assertTrue (ip3.isWellKnownMC());
assertTrue (!ip3.isNodeLocalMC());
assertTrue (!ip3.isLinkLocalMC());
assertTrue (ip3.isSiteLocalMC());
assertTrue (!ip3.isOrgLocalMC());
assertTrue (!ip3.isGlobalMC());
IPAddress ip4("ff18:0:0:0:0:0:0:FB"); // org local unicast
assert (!ip4.isWildcard());
assert (!ip4.isBroadcast());
assert (!ip4.isLoopback());
assert (ip4.isMulticast());
assert (!ip4.isUnicast());
assert (!ip4.isLinkLocal());
assert (!ip4.isSiteLocal());
assert (!ip4.isWellKnownMC());
assert (!ip4.isNodeLocalMC());
assert (!ip4.isLinkLocalMC());
assert (!ip4.isSiteLocalMC());
assert (ip4.isOrgLocalMC());
assert (!ip4.isGlobalMC());
assertTrue (!ip4.isWildcard());
assertTrue (!ip4.isBroadcast());
assertTrue (!ip4.isLoopback());
assertTrue (ip4.isMulticast());
assertTrue (!ip4.isUnicast());
assertTrue (!ip4.isLinkLocal());
assertTrue (!ip4.isSiteLocal());
assertTrue (!ip4.isWellKnownMC());
assertTrue (!ip4.isNodeLocalMC());
assertTrue (!ip4.isLinkLocalMC());
assertTrue (!ip4.isSiteLocalMC());
assertTrue (ip4.isOrgLocalMC());
assertTrue (!ip4.isGlobalMC());
IPAddress ip5("ff1f:0:0:0:0:0:0:FB"); // global unicast
assert (!ip5.isWildcard());
assert (!ip5.isBroadcast());
assert (!ip5.isLoopback());
assert (ip5.isMulticast());
assert (!ip5.isUnicast());
assert (!ip5.isLinkLocal());
assert (!ip5.isSiteLocal());
assert (!ip5.isWellKnownMC());
assert (!ip5.isNodeLocalMC());
assert (!ip5.isLinkLocalMC());
assert (!ip5.isSiteLocalMC());
assert (!ip5.isOrgLocalMC());
assert (ip5.isGlobalMC());
assertTrue (!ip5.isWildcard());
assertTrue (!ip5.isBroadcast());
assertTrue (!ip5.isLoopback());
assertTrue (ip5.isMulticast());
assertTrue (!ip5.isUnicast());
assertTrue (!ip5.isLinkLocal());
assertTrue (!ip5.isSiteLocal());
assertTrue (!ip5.isWellKnownMC());
assertTrue (!ip5.isNodeLocalMC());
assertTrue (!ip5.isLinkLocalMC());
assertTrue (!ip5.isSiteLocalMC());
assertTrue (!ip5.isOrgLocalMC());
assertTrue (ip5.isGlobalMC());
#endif
}
@@ -512,51 +512,51 @@ void IPAddressTest::testRelationals()
IPAddress ip3;
IPAddress ip4("10.0.0.138");
assert (ip1 != ip4);
assert (ip1 == ip2);
assert (!(ip1 != ip2));
assert (!(ip1 == ip4));
assert (ip1 > ip4);
assert (ip1 >= ip4);
assert (ip4 < ip1);
assert (ip4 <= ip1);
assert (!(ip1 < ip4));
assert (!(ip1 <= ip4));
assert (!(ip4 > ip1));
assert (!(ip4 >= ip1));
assertTrue (ip1 != ip4);
assertTrue (ip1 == ip2);
assertTrue (!(ip1 != ip2));
assertTrue (!(ip1 == ip4));
assertTrue (ip1 > ip4);
assertTrue (ip1 >= ip4);
assertTrue (ip4 < ip1);
assertTrue (ip4 <= ip1);
assertTrue (!(ip1 < ip4));
assertTrue (!(ip1 <= ip4));
assertTrue (!(ip4 > ip1));
assertTrue (!(ip4 >= ip1));
ip3 = ip1;
assert (ip1 == ip3);
assertTrue (ip1 == ip3);
ip3 = ip4;
assert (ip1 != ip3);
assert (ip3 == ip4);
assertTrue (ip1 != ip3);
assertTrue (ip3 == ip4);
}
void IPAddressTest::testWildcard()
{
IPAddress wildcard = IPAddress::wildcard();
assert (wildcard.isWildcard());
assert (wildcard.toString() == "0.0.0.0");
assertTrue (wildcard.isWildcard());
assertTrue (wildcard.toString() == "0.0.0.0");
}
void IPAddressTest::testBroadcast()
{
IPAddress broadcast = IPAddress::broadcast();
assert (broadcast.isBroadcast());
assert (broadcast.toString() == "255.255.255.255");
assertTrue (broadcast.isBroadcast());
assertTrue (broadcast.toString() == "255.255.255.255");
}
void IPAddressTest::testPrefixCons()
{
IPAddress ia1(15, IPAddress::IPv4);
assert(ia1.toString() == "255.254.0.0");
assertTrue (ia1.toString() == "255.254.0.0");
#ifdef POCO_HAVE_IPv6
IPAddress ia2(62, IPAddress::IPv6);
assert(ia2.toString() == "ffff:ffff:ffff:fffc::");
assertTrue (ia2.toString() == "ffff:ffff:ffff:fffc::");
#endif
}
@@ -564,32 +564,32 @@ void IPAddressTest::testPrefixCons()
void IPAddressTest::testPrefixLen()
{
IPAddress ia1(15, IPAddress::IPv4);
assert(ia1.prefixLength() == 15);
assertTrue (ia1.prefixLength() == 15);
IPAddress ia2(16, IPAddress::IPv4);
assert(ia2.prefixLength() == 16);
assertTrue (ia2.prefixLength() == 16);
IPAddress ia3(23, IPAddress::IPv4);
assert(ia3.prefixLength() == 23);
assertTrue (ia3.prefixLength() == 23);
IPAddress ia4(24, IPAddress::IPv4);
assert(ia4.prefixLength() == 24);
assertTrue (ia4.prefixLength() == 24);
IPAddress ia5(25, IPAddress::IPv4);
assert(ia5.prefixLength() == 25);
assertTrue (ia5.prefixLength() == 25);
#ifdef POCO_HAVE_IPv6
IPAddress ia6(62, IPAddress::IPv6);
assert(ia6.prefixLength() == 62);
assertTrue (ia6.prefixLength() == 62);
IPAddress ia7(63, IPAddress::IPv6);
assert(ia7.prefixLength() == 63);
assertTrue (ia7.prefixLength() == 63);
IPAddress ia8(64, IPAddress::IPv6);
assert(ia8.prefixLength() == 64);
assertTrue (ia8.prefixLength() == 64);
IPAddress ia9(65, IPAddress::IPv6);
assert(ia9.prefixLength() == 65);
assertTrue (ia9.prefixLength() == 65);
#endif
}
@@ -600,12 +600,12 @@ void IPAddressTest::testOperators()
IPAddress mask(24, IPAddress::IPv4);
IPAddress net = ip & mask;
assert(net.toString() == "10.0.0.0");
assertTrue (net.toString() == "10.0.0.0");
IPAddress host("0.0.0.51");
assert((net | host) == ip);
assertTrue ((net | host) == ip);
assert((~mask).toString() == "0.0.0.255");
assertTrue ((~mask).toString() == "0.0.0.255");
}
@@ -619,11 +619,11 @@ void IPAddressTest::testRelationals6()
void IPAddressTest::testByteOrderMacros()
{
Poco::UInt16 a16 = 0xDEAD;
assert (poco_ntoh_16(a16) == ntohs(a16));
assert (poco_hton_16(a16) == htons(a16));
assertTrue (poco_ntoh_16(a16) == ntohs(a16));
assertTrue (poco_hton_16(a16) == htons(a16));
Poco::UInt32 a32 = 0xDEADBEEF;
assert (poco_ntoh_32(a32) == ntohl(a32));
assert (poco_hton_32(a32) == htonl(a32));
assertTrue (poco_ntoh_32(a32) == ntohl(a32));
assertTrue (poco_hton_32(a32) == htonl(a32));
}

86
Net/testsuite/src/MailMessageTest.cpp
View File

@@ -116,13 +116,13 @@ void MailMessageTest::testWriteQP()
Timestamp ts(0);
message.setDate(ts);
assert (!message.isMultipart());
assertTrue (!message.isMultipart());
std::ostringstream str;
message.write(str);
std::string s = str.str();
assert (s ==
assertTrue (s ==
"Date: Thu, 1 Jan 1970 00:00:00 GMT\r\n"
"Content-Type: text/plain\r\n"
"Subject: Test Message\r\n"
@@ -158,7 +158,7 @@ void MailMessageTest::testWrite8Bit()
std::ostringstream str;
message.write(str);
std::string s = str.str();
assert (s ==
assertTrue (s ==
"Date: Thu, 1 Jan 1970 00:00:00 GMT\r\n"
"Content-Type: text/plain\r\n"
"Subject: Test Message\r\n"
@@ -190,7 +190,7 @@ void MailMessageTest::testWriteBase64()
std::ostringstream str;
message.write(str);
std::string s = str.str();
assert (s ==
assertTrue (s ==
"Date: Thu, 1 Jan 1970 00:00:00 GMT\r\n"
"Content-Type: text/plain\r\n"
"Subject: Test Message\r\n"
@@ -230,7 +230,7 @@ void MailMessageTest::testWriteManyRecipients()
std::ostringstream str;
message.write(str);
std::string s = str.str();
assert (s ==
assertTrue (s ==
"Date: Thu, 1 Jan 1970 00:00:00 GMT\r\n"
"Content-Type: text/plain\r\n"
"Subject: Test Message\r\n"
@@ -260,7 +260,7 @@ void MailMessageTest::testWriteMultiPart()
pSPS->headers().set("Content-ID", "abcd1234");
message.addAttachment("sample", pSPS);
assert (message.isMultipart());
assertTrue (message.isMultipart());
std::ostringstream str;
message.write(str);
@@ -301,7 +301,7 @@ void MailMessageTest::testWriteMultiPart()
msg += *it;
}
assert (s == msg);
assertTrue (s == msg);
}
@@ -325,9 +325,9 @@ void MailMessageTest::testReadQP()
MailMessage message;
message.read(istr);
assert (message.getSender() == "poco@appinf.com");
assert (message.getContentType() == "text/plain");
assert (message.getContent() ==
assertTrue (message.getSender() == "poco@appinf.com");
assertTrue (message.getContentType() == "text/plain");
assertTrue (message.getContent() ==
"Hello, world!\r\n"
"This is a test for the MailMessage class.\r\n"
"To test the quoted-printable encoding, we'll put an extra long line here. This should be enough.\r\n"
@@ -352,9 +352,9 @@ void MailMessageTest::testReadDefaultTransferEncoding()
MailMessage message;
message.read(istr);
assert (message.getSender() == "poco@appinf.com");
assert (message.getContentType() == "text/plain");
assert (message.getContent() ==
assertTrue (message.getSender() == "poco@appinf.com");
assertTrue (message.getContentType() == "text/plain");
assertTrue (message.getContent() ==
"Hello, world!\r\n"
"This is a test for the MailMessage class.\r\n"
);
@@ -378,9 +378,9 @@ void MailMessageTest::testRead8Bit()
MailMessage message;
message.read(istr);
assert (message.getSender() == "poco@appinf.com");
assert (message.getContentType() == "text/plain");
assert (message.getContent() ==
assertTrue (message.getSender() == "poco@appinf.com");
assertTrue (message.getContentType() == "text/plain");
assertTrue (message.getContent() ==
"Hello, world!\r\n"
"This is a test for the MailMessage class.\r\n"
);
@@ -418,14 +418,14 @@ void MailMessageTest::testReadMultiPart()
MailMessage message;
message.read(istr, handler);
assert (handler.data().size() == 2);
assert (handler.data()[0] == "Hello World!\r\n");
assert (handler.type()[0] == "text/plain");
assert (handler.disp()[0] == "inline");
assertTrue (handler.data().size() == 2);
assertTrue (handler.data()[0] == "Hello World!\r\n");
assertTrue (handler.type()[0] == "text/plain");
assertTrue (handler.disp()[0] == "inline");
assert (handler.data()[1] == "This is some binary data. Really.");
assert (handler.type()[1] == "application/octet-stream; name=sample");
assert (handler.disp()[1] == "attachment; filename=sample.dat");
assertTrue (handler.data()[1] == "This is some binary data. Really.");
assertTrue (handler.type()[1] == "application/octet-stream; name=sample");
assertTrue (handler.disp()[1] == "attachment; filename=sample.dat");
}
@@ -459,9 +459,9 @@ void MailMessageTest::testReadMultiPartWithAttachmentNames()
MailMessage message;
message.read(istr);
assert (message.parts().size() == 2);
assert (message.parts()[1].name == "sample");
assert (message.parts()[1].pSource->filename() == "sample.dat");
assertTrue (message.parts().size() == 2);
assertTrue (message.parts()[1].name == "sample");
assertTrue (message.parts()[1].pSource->filename() == "sample.dat");
}
@@ -495,14 +495,14 @@ void MailMessageTest::testReadMultiPartDefaultTransferEncoding()
MailMessage message;
message.read(istr, handler);
assert (handler.data().size() == 2);
assert (handler.data()[0] == "Hello World!\r\n");
assert (handler.type()[0] == "text/plain");
assert (handler.disp()[0] == "inline");
assertTrue (handler.data().size() == 2);
assertTrue (handler.data()[0] == "Hello World!\r\n");
assertTrue (handler.type()[0] == "text/plain");
assertTrue (handler.disp()[0] == "inline");
assert (handler.data()[1] == "This is some binary data. Really.");
assert (handler.type()[1] == "application/octet-stream; name=sample");
assert (handler.disp()[1] == "attachment; filename=sample.dat");
assertTrue (handler.data()[1] == "This is some binary data. Really.");
assertTrue (handler.type()[1] == "application/octet-stream; name=sample");
assertTrue (handler.disp()[1] == "attachment; filename=sample.dat");
}
@@ -541,7 +541,7 @@ void MailMessageTest::testReadWriteMultiPart()
message.write(ostr);
std::string msgout(ostr.str());
assert (msgout == msgin);
assertTrue (msgout == msgin);
}
@@ -587,27 +587,27 @@ void MailMessageTest::testReadWriteMultiPartStore()
if (fps && fps->filename().size())
{
std::string filename = fps->filename();
assert (filename == "sample.dat");
assertTrue (filename == "sample.dat");
std::string path = fps->path();
// for security reasons, the filesystem temporary
// filename is not the same as attachment name
std::size_t sz = (path.size() > filename.size()) ? filename.size() : path.size();
assert (0 != icompare(path, path.size() - sz, sz, path));
assertTrue (0 != icompare(path, path.size() - sz, sz, path));
Poco::FileInputStream fis(path);
assert (fis.good());
assertTrue (fis.good());
std::string read;
std::string line;
while (std::getline(fis, line)) read += line;
assert (!read.empty());
assert (read == "This is some binary data. Really.");
assertTrue (!read.empty());
assertTrue (read == "This is some binary data. Really.");
}
}
message.write(ostr);
std::string msgout(ostr.str());
assert (msgout == msgin);
assertTrue (msgout == msgin);
}
@@ -615,18 +615,18 @@ void MailMessageTest::testEncodeWord()
{
std::string plain("this is pure ASCII");
std::string encoded = MailMessage::encodeWord(plain, "ISO-8859-1");
assert (encoded == plain);
assertTrue (encoded == plain);
plain = "This text contains German Umlauts: \304\326";
encoded = MailMessage::encodeWord(plain, "ISO-8859-1");
assert (encoded == "=?ISO-8859-1?q?This_text_contains_German_Umlauts=3A_=C4=D6?=");
assertTrue (encoded == "=?ISO-8859-1?q?This_text_contains_German_Umlauts=3A_=C4=D6?=");
plain = "This text contains German Umlauts: \304\326. "
"It is also a very long text. Longer than 75 "
"characters. Long enough to become three lines "
"after being word-encoded.";
encoded = MailMessage::encodeWord(plain, "ISO-8859-1");
assert (encoded == "=?ISO-8859-1?q?This_text_contains_German_Umlauts=3A_=C4=D6=2E_It_?=\r\n"
assertTrue (encoded == "=?ISO-8859-1?q?This_text_contains_German_Umlauts=3A_=C4=D6=2E_It_?=\r\n"
" =?ISO-8859-1?q?is_also_a_very_long_text=2E_Longer_than_75_characters=2E_?=\r\n"
" =?ISO-8859-1?q?Long_enough_to_become_three_lines_after_being_word-encode?=\r\n"
" =?ISO-8859-1?q?d=2E?=");

4
Net/testsuite/src/MailStreamTest.cpp
View File

@@ -50,7 +50,7 @@ void MailStreamTest::testMailInputStream()
std::ostringstream ostr;
StreamCopier::copyStream(mis, ostr);
std::string s(ostr.str());
assert (s ==
assertTrue (s ==
"From: john.doe@no.domain\r\n"
"To: jane.doe@no.domain\r\n"
"Subject: test\r\n"
@@ -84,7 +84,7 @@ void MailStreamTest::testMailOutputStream()
mos << msg;
mos.close();
std::string s(ostr.str());
assert (s ==
assertTrue (s ==
"From: john.doe@no.domain\r\n"
"To: jane.doe@no.domain\r\n"
"Subject: test\r\n"

76
Net/testsuite/src/MediaTypeTest.cpp
View File

@@ -30,37 +30,37 @@ MediaTypeTest::~MediaTypeTest()
void MediaTypeTest::testParse()
{
MediaType mt1("text/plain");
assert (mt1.getType() == "text");
assert (mt1.getSubType() == "plain");
assert (mt1.parameters().empty());
assertTrue (mt1.getType() == "text");
assertTrue (mt1.getSubType() == "plain");
assertTrue (mt1.parameters().empty());
MediaType mt2("text/xml;charset=us-ascii");
assert (mt2.getType() == "text");
assert (mt2.getSubType() == "xml");
assert (!mt2.parameters().empty());
assert (mt2.getParameter("charset") == "us-ascii");
assertTrue (mt2.getType() == "text");
assertTrue (mt2.getSubType() == "xml");
assertTrue (!mt2.parameters().empty());
assertTrue (mt2.getParameter("charset") == "us-ascii");
MediaType mt3("application/test; param1=value1; param2=\"value 2\"");
assert (mt3.getType() == "application");
assert (mt3.getSubType() == "test");
assert (!mt3.parameters().empty());
assert (mt3.getParameter("param1") == "value1");
assert (mt3.getParameter("PARAM2") == "value 2");
assertTrue (mt3.getType() == "application");
assertTrue (mt3.getSubType() == "test");
assertTrue (!mt3.parameters().empty());
assertTrue (mt3.getParameter("param1") == "value1");
assertTrue (mt3.getParameter("PARAM2") == "value 2");
}
void MediaTypeTest::testToString()
{
MediaType mt1("text", "plain");
assert (mt1.toString() == "text/plain");
assertTrue (mt1.toString() == "text/plain");
mt1.setParameter("charset", "iso-8859-1");
assert (mt1.toString() == "text/plain; charset=iso-8859-1");
assertTrue (mt1.toString() == "text/plain; charset=iso-8859-1");
MediaType mt2("application", "test");
mt2.setParameter("param1", "value1");
mt2.setParameter("param2", "value 2");
assert (mt2.toString() == "application/test; param1=value1; param2=\"value 2\"");
assertTrue (mt2.toString() == "application/test; param1=value1; param2=\"value 2\"");
}
@@ -69,11 +69,11 @@ void MediaTypeTest::testMatch()
MediaType mt1("Text/Plain");
MediaType mt2("text/plain");
MediaType mt3("text/xml");
assert (mt1.matches(mt2));
assert (!mt1.matches(mt3));
assert (mt1.matches("text"));
assert (mt2.matches("text"));
assert (mt3.matches("text"));
assertTrue (mt1.matches(mt2));
assertTrue (!mt1.matches(mt3));
assertTrue (mt1.matches("text"));
assertTrue (mt2.matches("text"));
assertTrue (mt3.matches("text"));
}
@@ -85,27 +85,27 @@ void MediaTypeTest::testMatchRange()
MediaType mt4("image/jpg");
MediaType mt5("text/*");
MediaType mt6("*/*");
assert (mt1.matchesRange(mt5));
assert (mt2.matchesRange(mt5));
assert (mt3.matchesRange(mt5));
assert (!mt4.matchesRange(mt5));
assert (mt1.matchesRange(mt6));
assert (mt2.matchesRange(mt6));
assert (mt3.matchesRange(mt6));
assert (mt4.matchesRange(mt6));
assertTrue (mt1.matchesRange(mt5));
assertTrue (mt2.matchesRange(mt5));
assertTrue (mt3.matchesRange(mt5));
assertTrue (!mt4.matchesRange(mt5));
assertTrue (mt1.matchesRange(mt6));
assertTrue (mt2.matchesRange(mt6));
assertTrue (mt3.matchesRange(mt6));
assertTrue (mt4.matchesRange(mt6));
assert (mt5.matchesRange(mt1));
assert (mt5.matchesRange(mt2));
assert (mt5.matchesRange(mt3));
assert (!mt5.matchesRange(mt4));
assertTrue (mt5.matchesRange(mt1));
assertTrue (mt5.matchesRange(mt2));
assertTrue (mt5.matchesRange(mt3));
assertTrue (!mt5.matchesRange(mt4));
assert (mt1.matchesRange("text", "*"));
assert (mt2.matchesRange("text", "*"));
assert (mt3.matchesRange("text", "*"));
assert (!mt4.matchesRange("text", "*"));
assertTrue (mt1.matchesRange("text", "*"));
assertTrue (mt2.matchesRange("text", "*"));
assertTrue (mt3.matchesRange("text", "*"));
assertTrue (!mt4.matchesRange("text", "*"));
assert (mt1.matchesRange("*"));
assert (mt4.matchesRange("*"));
assertTrue (mt1.matchesRange("*"));
assertTrue (mt4.matchesRange("*"));
}

204
Net/testsuite/src/MessageHeaderTest.cpp
View File

@@ -41,7 +41,7 @@ void MessageHeaderTest::testWrite()
std::ostringstream ostr;
mh.write(ostr);
std::string s = ostr.str();
assert (s == "name1: value1\r\nname2: value2\r\nname3: value3\r\n");
assertTrue (s == "name1: value1\r\nname2: value2\r\nname3: value3\r\n");
}
@@ -51,10 +51,10 @@ void MessageHeaderTest::testRead1()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value2");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value2");
assertTrue (mh["name3"] == "value3");
}
@@ -64,10 +64,10 @@ void MessageHeaderTest::testRead2()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value2");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value2");
assertTrue (mh["name3"] == "value3");
}
@@ -77,8 +77,8 @@ void MessageHeaderTest::testRead3()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 1);
assert (mh["name1"] == "value1");
assertTrue (mh.size() == 1);
assertTrue (mh["name1"] == "value1");
}
@@ -89,15 +89,15 @@ void MessageHeaderTest::testRead4()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 2);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value2");
assertTrue (mh.size() == 2);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value2");
int ch = istr.get();
assert (ch == '\r');
assertTrue (ch == '\r');
ch = istr.get();
assert (ch == '\n');
assertTrue (ch == '\n');
ch = istr.get();
assert (ch == 's');
assertTrue (ch == 's');
}
@@ -107,10 +107,10 @@ void MessageHeaderTest::testRead5()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "");
assert (mh["name2"] == "value2");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "");
assertTrue (mh["name2"] == "value2");
assertTrue (mh["name3"] == "value3");
}
@@ -120,10 +120,10 @@ void MessageHeaderTest::testReadFolding1()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value21 value22");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value21 value22");
assertTrue (mh["name3"] == "value3");
}
@@ -133,10 +133,10 @@ void MessageHeaderTest::testReadFolding2()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value21\tvalue22");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value21\tvalue22");
assertTrue (mh["name3"] == "value3");
}
@@ -146,9 +146,9 @@ void MessageHeaderTest::testReadFolding3()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 2);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value21 value22");
assertTrue (mh.size() == 2);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value21 value22");
}
@@ -158,9 +158,9 @@ void MessageHeaderTest::testReadFolding4()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 2);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value21 value22 value23");
assertTrue (mh.size() == 2);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value21 value22 value23");
}
@@ -170,10 +170,10 @@ void MessageHeaderTest::testReadFolding5()
std::istringstream istr(s);
MessageHeader mh;
mh.read(istr);
assert (mh.size() == 3);
assert (mh["name1"] == "value1");
assert (mh["name2"] == "value21 value22 value23");
assert (mh["name3"] == "value3");
assertTrue (mh.size() == 3);
assertTrue (mh["name1"] == "value1");
assertTrue (mh["name2"] == "value21 value22 value23");
assertTrue (mh["name3"] == "value3");
}
@@ -216,74 +216,74 @@ void MessageHeaderTest::testSplitElements()
std::string s;
std::vector<std::string> v;
MessageHeader::splitElements(s, v);
assert (v.empty());
assertTrue (v.empty());
s = "foo";
MessageHeader::splitElements(s, v);
assert (v.size() == 1);
assert (v[0] == "foo");
assertTrue (v.size() == 1);
assertTrue (v[0] == "foo");
s = " foo ";
MessageHeader::splitElements(s, v);
assert (v.size() == 1);
assert (v[0] == "foo");
assertTrue (v.size() == 1);
assertTrue (v[0] == "foo");
s = "foo,bar";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "foo");
assert (v[1] == "bar");
assertTrue (v.size() == 2);
assertTrue (v[0] == "foo");
assertTrue (v[1] == "bar");
s = "foo,,bar";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "foo");
assert (v[1] == "bar");
assertTrue (v.size() == 2);
assertTrue (v[0] == "foo");
assertTrue (v[1] == "bar");
MessageHeader::splitElements(s, v, false);
assert (v.size() == 3);
assert (v[0] == "foo");
assert (v[1] == "");
assert (v[2] == "bar");
assertTrue (v.size() == 3);
assertTrue (v[0] == "foo");
assertTrue (v[1] == "");
assertTrue (v[2] == "bar");
s = "foo;param=\"a,b\",bar;param=\"c,d\"";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "foo;param=\"a,b\"");
assert (v[1] == "bar;param=\"c,d\"");
assertTrue (v.size() == 2);
assertTrue (v[0] == "foo;param=\"a,b\"");
assertTrue (v[1] == "bar;param=\"c,d\"");
s = "foo; param=\"a,b\", bar; param=\"c,d\"";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "foo; param=\"a,b\"");
assert (v[1] == "bar; param=\"c,d\"");
assertTrue (v.size() == 2);
assertTrue (v[0] == "foo; param=\"a,b\"");
assertTrue (v[1] == "bar; param=\"c,d\"");
s = "foo, bar, f00, baz";
MessageHeader::splitElements(s, v);
assert (v.size() == 4);
assert (v[0] == "foo");
assert (v[1] == "bar");
assert (v[2] == "f00");
assert (v[3] == "baz");
assertTrue (v.size() == 4);
assertTrue (v[0] == "foo");
assertTrue (v[1] == "bar");
assertTrue (v[2] == "f00");
assertTrue (v[3] == "baz");
s = "a,b,c";
MessageHeader::splitElements(s, v);
assert (v.size() == 3);
assert (v[0] == "a");
assert (v[1] == "b");
assert (v[2] == "c");
assertTrue (v.size() == 3);
assertTrue (v[0] == "a");
assertTrue (v[1] == "b");
assertTrue (v[2] == "c");
s = "a=\"value=\\\\\\\"foo, bar\\\\\\\"\",b=foo";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "a=\"value=\\\"foo, bar\\\"\"");
assert (v[1] == "b=foo");
assertTrue (v.size() == 2);
assertTrue (v[0] == "a=\"value=\\\"foo, bar\\\"\"");
assertTrue (v[1] == "b=foo");
s = "a=\\\",b=\\\"";
MessageHeader::splitElements(s, v);
assert (v.size() == 2);
assert (v[0] == "a=\"");
assert (v[1] == "b=\"");
assertTrue (v.size() == 2);
assertTrue (v[0] == "a=\"");
assertTrue (v[1] == "b=\"");
}
@@ -295,51 +295,51 @@ void MessageHeaderTest::testSplitParameters()
NameValueCollection p;
MessageHeader::splitParameters(s, v, p);
assert (v.empty());
assert (p.empty());
assertTrue (v.empty());
assertTrue (p.empty());
s = "multipart/related";
MessageHeader::splitParameters(s, v, p);
assert (v == "multipart/related");
assert (p.empty());
assertTrue (v == "multipart/related");
assertTrue (p.empty());
s = "multipart/related; boundary=MIME_boundary_01234567";
MessageHeader::splitParameters(s, v, p);
assert (v == "multipart/related");
assert (p.size() == 1);
assert (p["boundary"] == "MIME_boundary_01234567");
assertTrue (v == "multipart/related");
assertTrue (p.size() == 1);
assertTrue (p["boundary"] == "MIME_boundary_01234567");
s = "multipart/related; boundary=\"MIME_boundary_76543210\"";
MessageHeader::splitParameters(s, v, p);
assert (v == "multipart/related");
assert (p.size() == 1);
assert (p["boundary"] == "MIME_boundary_76543210");
assertTrue (v == "multipart/related");
assertTrue (p.size() == 1);
assertTrue (p["boundary"] == "MIME_boundary_76543210");
s = "text/plain; charset=us-ascii";
MessageHeader::splitParameters(s, v, p);
assert (v == "text/plain");
assert (p.size() == 1);
assert (p["charset"] == "us-ascii");
assertTrue (v == "text/plain");
assertTrue (p.size() == 1);
assertTrue (p["charset"] == "us-ascii");
s = "value; p1=foo; p2=bar";
MessageHeader::splitParameters(s, v, p);
assert (v == "value");
assert (p.size() == 2);
assert (p["p1"] == "foo");
assert (p["p2"] == "bar");
assertTrue (v == "value");
assertTrue (p.size() == 2);
assertTrue (p["p1"] == "foo");
assertTrue (p["p2"] == "bar");
s = "value; p1=\"foo; bar\"";
MessageHeader::splitParameters(s, v, p);
assert (v == "value");
assert (p.size() == 1);
assert (p["p1"] == "foo; bar");
assertTrue (v == "value");
assertTrue (p.size() == 1);
assertTrue (p["p1"] == "foo; bar");
s = "value ; p1=foo ; p2=bar ";
MessageHeader::splitParameters(s, v, p);
assert (v == "value");
assert (p.size() == 2);
assert (p["p1"] == "foo");
assert (p["p2"] == "bar");
assertTrue (v == "value");
assertTrue (p.size() == 2);
assertTrue (p["p1"] == "foo");
assertTrue (p["p2"] == "bar");
}
@@ -364,15 +364,15 @@ void MessageHeaderTest::testDecodeWord()
{
std::string coded("this is pure ASCII");
std::string decoded = MessageHeader::decodeWord(coded, "ISO-8859-1");
assert(decoded == coded);
assertTrue (decoded == coded);
coded = "(=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=)";
decoded = MessageHeader::decodeWord(coded, "ISO-8859-1");
assert(decoded == "(a b)");
assertTrue (decoded == "(a b)");
coded = "Hello =?UTF-8?B?RnJhbmNpcw==?=, good bye";
decoded = MessageHeader::decodeWord(coded, "ISO-8859-1");
assert(decoded == "Hello Francis, good bye");
assertTrue (decoded == "Hello Francis, good bye");
}

6
Net/testsuite/src/MulticastSocketTest.cpp
View File

@@ -52,11 +52,11 @@ void MulticastSocketTest::testMulticast()
MulticastEchoServer echoServer;
MulticastSocket ms(SocketAddress::IPv4);
int n = ms.sendTo("hello", 5, echoServer.group());
assert (n == 5);
assertTrue (n == 5);
char buffer[256];
n = ms.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ms.close();
}
catch (Poco::NotImplementedException e)

102
Net/testsuite/src/MultipartReaderTest.cpp
View File

@@ -37,12 +37,12 @@ void MultipartReaderTest::testReadOnePart()
std::string s("\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.boundary() == "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.boundary() == "MIME_boundary_01234567");
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -51,8 +51,8 @@ void MultipartReaderTest::testReadOnePart()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (!r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (!r.hasNextPart());
try
{
r.nextPart(h);
@@ -69,11 +69,11 @@ void MultipartReaderTest::testReadTwoParts()
std::string s("\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567\r\n\r\nthis is part 2\r\n\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -82,10 +82,10 @@ void MultipartReaderTest::testReadTwoParts()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (r.hasNextPart());
r.nextPart(h);
assert (h.empty());
assertTrue (h.empty());
std::istream& ii = r.stream();
part.clear();
ch = ii.get();
@@ -94,7 +94,7 @@ void MultipartReaderTest::testReadTwoParts()
part += (char) ch;
ch = ii.get();
}
assert (part == "this is part 2\r\n");
assertTrue (part == "this is part 2\r\n");
try
{
@@ -112,11 +112,11 @@ void MultipartReaderTest::testReadEmptyLines()
std::string s("\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is\r\npart 1\r\n\r\n--MIME_boundary_01234567\r\n\r\nthis\r\n\r\nis part 2\r\n\r\n\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -125,10 +125,10 @@ void MultipartReaderTest::testReadEmptyLines()
part += (char) ch;
ch = i.get();
}
assert (part == "this is\r\npart 1\r\n");
assert (r.hasNextPart());
assertTrue (part == "this is\r\npart 1\r\n");
assertTrue (r.hasNextPart());
r.nextPart(h);
assert (h.empty());
assertTrue (h.empty());
std::istream& ii = r.stream();
part.clear();
ch = ii.get();
@@ -137,7 +137,7 @@ void MultipartReaderTest::testReadEmptyLines()
part += (char) ch;
ch = ii.get();
}
assert (part == "this\r\n\r\nis part 2\r\n\r\n");
assertTrue (part == "this\r\n\r\nis part 2\r\n\r\n");
try
{
@@ -158,11 +158,11 @@ void MultipartReaderTest::testReadLongPart()
s.append("\r\n--MIME_boundary_01234567\r\n\r\nthis is part 2\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -171,10 +171,10 @@ void MultipartReaderTest::testReadLongPart()
part += (char) ch;
ch = i.get();
}
assert (part == longPart);
assert (r.hasNextPart());
assertTrue (part == longPart);
assertTrue (r.hasNextPart());
r.nextPart(h);
assert (h.empty());
assertTrue (h.empty());
std::istream& ii = r.stream();
part.clear();
ch = ii.get();
@@ -183,7 +183,7 @@ void MultipartReaderTest::testReadLongPart()
part += (char) ch;
ch = ii.get();
}
assert (part == "this is part 2");
assertTrue (part == "this is part 2");
try
{
@@ -201,12 +201,12 @@ void MultipartReaderTest::testGuessBoundary()
std::string s("\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr);
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (r.boundary() == "MIME_boundary_01234567");
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (r.boundary() == "MIME_boundary_01234567");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -215,8 +215,8 @@ void MultipartReaderTest::testGuessBoundary()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (!r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (!r.hasNextPart());
try
{
r.nextPart(h);
@@ -233,11 +233,11 @@ void MultipartReaderTest::testPreamble()
std::string s("this is the\r\npreamble\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -246,8 +246,8 @@ void MultipartReaderTest::testPreamble()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (!r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (!r.hasNextPart());
try
{
r.nextPart(h);
@@ -264,7 +264,7 @@ void MultipartReaderTest::testBadBoundary()
std::string s("\r\n--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_7654321");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
try
{
@@ -281,11 +281,11 @@ void MultipartReaderTest::testRobustness()
std::string s("--MIME_boundary_01234567\rname1: value1\r\n\nthis is part 1\n--MIME_boundary_01234567--");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -294,8 +294,8 @@ void MultipartReaderTest::testRobustness()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (!r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (!r.hasNextPart());
try
{
r.nextPart(h);
@@ -312,11 +312,11 @@ void MultipartReaderTest::testUnixLineEnds()
std::string s("\n--MIME_boundary_01234567\nname1: value1\n\nthis is part 1\n--MIME_boundary_01234567\n\nthis is part 2\n\n--MIME_boundary_01234567--\n");
std::istringstream istr(s);
MultipartReader r(istr, "MIME_boundary_01234567");
assert (r.hasNextPart());
assertTrue (r.hasNextPart());
MessageHeader h;
r.nextPart(h);
assert (h.size() == 1);
assert (h["name1"] == "value1");
assertTrue (h.size() == 1);
assertTrue (h["name1"] == "value1");
std::istream& i = r.stream();
int ch = i.get();
std::string part;
@@ -325,10 +325,10 @@ void MultipartReaderTest::testUnixLineEnds()
part += (char) ch;
ch = i.get();
}
assert (part == "this is part 1");
assert (r.hasNextPart());
assertTrue (part == "this is part 1");
assertTrue (r.hasNextPart());
r.nextPart(h);
assert (h.empty());
assertTrue (h.empty());
std::istream& ii = r.stream();
part.clear();
ch = ii.get();
@@ -337,7 +337,7 @@ void MultipartReaderTest::testUnixLineEnds()
part += (char) ch;
ch = ii.get();
}
assert (part == "this is part 2\n");
assertTrue (part == "this is part 2\n");
try
{

10
Net/testsuite/src/MultipartWriterTest.cpp
View File

@@ -34,14 +34,14 @@ void MultipartWriterTest::testWriteOnePart()
{
std::ostringstream ostr;
MultipartWriter w(ostr, "MIME_boundary_01234567");
assert (w.boundary() == "MIME_boundary_01234567");
assertTrue (w.boundary() == "MIME_boundary_01234567");
MessageHeader h;
h.set("name1", "value1");
w.nextPart(h);
ostr << "this is part 1";
w.close();
std::string s = ostr.str();
assert (s == "--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
assertTrue (s == "--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567--\r\n");
}
@@ -58,7 +58,7 @@ void MultipartWriterTest::testWriteTwoParts()
ostr << "this is part 2";
w.close();
std::string s = ostr.str();
assert (s == "--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567\r\n\r\nthis is part 2\r\n--MIME_boundary_01234567--\r\n");
assertTrue (s == "--MIME_boundary_01234567\r\nname1: value1\r\n\r\nthis is part 1\r\n--MIME_boundary_01234567\r\n\r\nthis is part 2\r\n--MIME_boundary_01234567--\r\n");
}
@@ -67,8 +67,8 @@ void MultipartWriterTest::testBoundary()
std::ostringstream ostr;
MultipartWriter w(ostr);
std::string boundary = w.boundary();
assert (boundary.substr(0, 14) == "MIME_boundary_");
assert (boundary.length() == 14 + 16);
assertTrue (boundary.substr(0, 14) == "MIME_boundary_");
assertTrue (boundary.length() == 14 + 16);
}

2
Net/testsuite/src/NTPClientTest.cpp
View File

@@ -56,7 +56,7 @@ void NTPClientTest::testTimeSync()
}
#endif
assert(_ntpClient.request("pool.ntp.org") > 0);
assertTrue (_ntpClient.request("pool.ntp.org") > 0);
}

52
Net/testsuite/src/NameValueCollectionTest.cpp
View File

@@ -33,19 +33,19 @@ void NameValueCollectionTest::testNameValueCollection()
{
NameValueCollection nvc;
assert (nvc.empty());
assert (nvc.size() == 0);
assertTrue (nvc.empty());
assertTrue (nvc.size() == 0);
nvc.set("name", "value");
assert (!nvc.empty());
assert (nvc["name"] == "value");
assert (nvc["Name"] == "value");
assertTrue (!nvc.empty());
assertTrue (nvc["name"] == "value");
assertTrue (nvc["Name"] == "value");
nvc.set("name2", "value2");
assert (nvc.get("name2") == "value2");
assert (nvc.get("NAME2") == "value2");
assertTrue (nvc.get("name2") == "value2");
assertTrue (nvc.get("NAME2") == "value2");
assert (nvc.size() == 2);
assertTrue (nvc.size() == 2);
try
{
@@ -65,44 +65,44 @@ void NameValueCollectionTest::testNameValueCollection()
{
}
assert (nvc.get("name", "default") == "value");
assert (nvc.get("name3", "default") == "default");
assertTrue (nvc.get("name", "default") == "value");
assertTrue (nvc.get("name3", "default") == "default");
assert (nvc.has("name"));
assert (nvc.has("name2"));
assert (!nvc.has("name3"));
assertTrue (nvc.has("name"));
assertTrue (nvc.has("name2"));
assertTrue (!nvc.has("name3"));
nvc.add("name3", "value3");
assert (nvc.get("name3") == "value3");
assertTrue (nvc.get("name3") == "value3");
nvc.add("name3", "value31");
NameValueCollection::ConstIterator it = nvc.find("Name3");
assert (it != nvc.end());
assertTrue (it != nvc.end());
std::string v1 = it->second;
assert (it->first == "name3");
assertTrue (it->first == "name3");
++it;
assert (it != nvc.end());
assertTrue (it != nvc.end());
std::string v2 = it->second;
assert (it->first == "name3");
assertTrue (it->first == "name3");
assert ((v1 == "value3" && v2 == "value31") || (v1 == "value31" && v2 == "value3"));
assertTrue ((v1 == "value3" && v2 == "value31") || (v1 == "value31" && v2 == "value3"));
nvc.erase("name3");
assert (!nvc.has("name3"));
assert (nvc.find("name3") == nvc.end());
assertTrue (!nvc.has("name3"));
assertTrue (nvc.find("name3") == nvc.end());
it = nvc.begin();
assert (it != nvc.end());
assertTrue (it != nvc.end());
++it;
assert (it != nvc.end());
assertTrue (it != nvc.end());
++it;
assert (it == nvc.end());
assertTrue (it == nvc.end());
nvc.clear();
assert (nvc.empty());
assertTrue (nvc.empty());
assert (nvc.size() == 0);
assertTrue (nvc.size() == 0);
}

34
Net/testsuite/src/NetworkInterfaceTest.cpp
View File

@@ -42,7 +42,7 @@ void NetworkInterfaceTest::testMap()
try
{
NetworkInterface::Map m = NetworkInterface::map(false, false);
assert (!m.empty());
assertTrue (!m.empty());
for (NetworkInterface::Map::const_iterator it = m.begin(); it != m.end(); ++it)
{
std::cout << std::endl << "=============" << std::endl;
@@ -89,7 +89,7 @@ void NetworkInterfaceTest::testList()
try
{
NetworkInterface::List list = NetworkInterface::list(false, false);
assert (!list.empty());
assertTrue (!list.empty());
for (NetworkInterface::List::const_iterator it = list.begin(); it != list.end(); ++it)
{
std::cout << std::endl << "==============" << std::endl;
@@ -136,7 +136,7 @@ void NetworkInterfaceTest::testForName()
for (NetworkInterface::Map::const_iterator it = map.begin(); it != map.end(); ++it)
{
NetworkInterface ifc = NetworkInterface::forName(it->second.name());
assert (ifc.name() == it->second.name());
assertTrue (ifc.name() == it->second.name());
}
}
catch (Poco::NotImplementedException e)
@@ -161,12 +161,12 @@ void NetworkInterfaceTest::testForAddress()
if (it->second.supportsIPv4())
{
NetworkInterface ifc = NetworkInterface::forAddress(it->second.firstAddress(IPAddress::IPv4));
assert (ifc.firstAddress(IPAddress::IPv4) == it->second.firstAddress(IPAddress::IPv4));
assertTrue (ifc.firstAddress(IPAddress::IPv4) == it->second.firstAddress(IPAddress::IPv4));
IPAddress addr(IPAddress::IPv4);
assert (addr.isWildcard());
assertTrue (addr.isWildcard());
it->second.firstAddress(addr, IPAddress::IPv4);
assert (!addr.isWildcard());
assertTrue (!addr.isWildcard());
}
else
{
@@ -178,9 +178,9 @@ void NetworkInterfaceTest::testForAddress()
catch (NotFoundException&) { }
IPAddress addr(IPAddress::IPv4);
assert (addr.isWildcard());
assertTrue (addr.isWildcard());
it->second.firstAddress(addr, IPAddress::IPv4);
assert (addr.isWildcard());
assertTrue (addr.isWildcard());
}
}
}
@@ -201,7 +201,7 @@ void NetworkInterfaceTest::testForIndex()
for (NetworkInterface::Map::const_iterator it = map.begin(); it != map.end(); ++it)
{
NetworkInterface ifc = NetworkInterface::forIndex(it->second.index());
assert (ifc.index() == it->second.index());
assertTrue (ifc.index() == it->second.index());
}
}
catch (Poco::NotImplementedException e)
@@ -218,12 +218,12 @@ void NetworkInterfaceTest::testMapIpOnly()
try
{
NetworkInterface::Map m = NetworkInterface::map(true, false);
assert (!m.empty());
assertTrue (!m.empty());
std::cout << std::endl;
for (NetworkInterface::Map::const_iterator it = m.begin(); it != m.end(); ++it)
{
assert(it->second.supportsIPv4() || it->second.supportsIPv6());
assertTrue (it->second.supportsIPv4() || it->second.supportsIPv6());
std::cout << "Interface: (" << it->second.index() << ")" << std::endl;
std::cout << "Address: " << it->second.address() << std::endl;
NetworkInterface::MACAddress mac(it->second.macAddress());
@@ -245,10 +245,10 @@ void NetworkInterfaceTest::testMapUpOnly()
try
{
NetworkInterface::Map m = NetworkInterface::map(false, true);
assert (!m.empty());
assertTrue (!m.empty());
for (NetworkInterface::Map::const_iterator it = m.begin(); it != m.end(); ++it)
{
assert(it->second.isUp());
assertTrue (it->second.isUp());
}
}
catch (Poco::NotImplementedException e)
@@ -265,9 +265,9 @@ void NetworkInterfaceTest::testListMapConformance()
try
{
NetworkInterface::Map m = NetworkInterface::map(false, false);
assert (!m.empty());
assertTrue (!m.empty());
NetworkInterface::List l = NetworkInterface::list(false, false);
assert (!l.empty());
assertTrue (!l.empty());
int counter = 0;
NetworkInterface::Map::const_iterator mapIt = m.begin();
@@ -286,7 +286,7 @@ void NetworkInterfaceTest::testListMapConformance()
{
if(listIt == l.end()) fail("wrong number of list items");
NetworkInterface::MACAddress lmac = listIt->macAddress();
assert (lmac == mac);
assertTrue (lmac == mac);
}
}
else
@@ -296,7 +296,7 @@ void NetworkInterfaceTest::testListMapConformance()
}
}
assert (counter == l.size());
assertTrue (counter == l.size());
}
catch (Poco::NotImplementedException e)
{

20
Net/testsuite/src/OAuth10CredentialsTest.cpp
View File

@@ -62,7 +62,7 @@ void OAuth10CredentialsTest::testCallback()
creds.authenticate(request, uri);
std::string auth = request.get("Authorization");
assert (auth == "OAuth"
assertTrue (auth == "OAuth"
" oauth_consumer_key=\"cChZNFj6T5R0TigYB9yd1w\","
" oauth_nonce=\"ea9ec8429b68d6b77cd5600adbbb0456\","
" oauth_signature=\"F1Li3tvehgcraF8DMJ7OyxO4w9Y%3D\","
@@ -110,7 +110,7 @@ void OAuth10CredentialsTest::testParams()
creds.authenticate(request, uri, params);
std::string auth = request.get("Authorization");
assert (auth == "OAuth"
assertTrue (auth == "OAuth"
" oauth_consumer_key=\"xvz1evFS4wEEPTGEFPHBog\","
" oauth_nonce=\"kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg\","
" oauth_signature=\"tnnArxj06cWHq44gCs1OSKk%2FjLY%3D\","
@@ -160,7 +160,7 @@ void OAuth10CredentialsTest::testRealm()
creds.authenticate(request, uri, params);
std::string auth = request.get("Authorization");
assert (auth == "OAuth"
assertTrue (auth == "OAuth"
" realm=\"Twitter API\","
" oauth_consumer_key=\"xvz1evFS4wEEPTGEFPHBog\","
" oauth_nonce=\"kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg\","
@@ -183,7 +183,7 @@ void OAuth10CredentialsTest::testPlaintext()
std::string auth = request.get("Authorization");
assert (auth == "OAuth"
assertTrue (auth == "OAuth"
" oauth_consumer_key=\"consumerKey\","
" oauth_signature=\"consumerSecret%26\","
" oauth_signature_method=\"PLAINTEXT\","
@@ -206,8 +206,8 @@ void OAuth10CredentialsTest::testVerify()
" oauth_version=\"1.0\"");
OAuth10Credentials creds(request);
assert (creds.getConsumerKey() == "xvz1evFS4wEEPTGEFPHBog");
assert (creds.getToken() == "370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb");
assertTrue (creds.getConsumerKey() == "xvz1evFS4wEEPTGEFPHBog");
assertTrue (creds.getToken() == "370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb");
creds.setConsumerSecret("kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw");
creds.setTokenSecret("LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE");
@@ -215,7 +215,7 @@ void OAuth10CredentialsTest::testVerify()
params.read(uri.getRawQuery());
params.read("status=Hello%20Ladies%20%2b%20Gentlemen%2c%20a%20signed%20OAuth%20request%21");
assert (creds.verify(request, uri, params));
assertTrue (creds.verify(request, uri, params));
}
@@ -231,11 +231,11 @@ void OAuth10CredentialsTest::testVerifyPlaintext()
" oauth_version=\"1.0\"");
OAuth10Credentials creds(request);
assert (creds.getConsumerKey() == "consumerKey");
assertTrue (creds.getConsumerKey() == "consumerKey");
creds.setConsumerSecret("consumerSecret");
assert (creds.verify(request, uri));
assert (creds.getCallback() == "http://localhost/sign-in-with-twitter/");
assertTrue (creds.verify(request, uri));
assertTrue (creds.getCallback() == "http://localhost/sign-in-with-twitter/");
}

8
Net/testsuite/src/OAuth20CredentialsTest.cpp
View File

@@ -37,7 +37,7 @@ void OAuth20CredentialsTest::testAuthorize()
HTTPRequest request(HTTPRequest::HTTP_GET, "/");
creds.authenticate(request);
std::string auth = request.get("Authorization");
assert (auth == "Bearer s3cr3tt0k3n");
assertTrue (auth == "Bearer s3cr3tt0k3n");
}
@@ -47,7 +47,7 @@ void OAuth20CredentialsTest::testAuthorizeCustomScheme()
HTTPRequest request(HTTPRequest::HTTP_GET, "/");
creds.authenticate(request);
std::string auth = request.get("Authorization");
assert (auth == "token s3cr3tt0k3n");
assertTrue (auth == "token s3cr3tt0k3n");
}
@@ -56,7 +56,7 @@ void OAuth20CredentialsTest::testExtract()
HTTPRequest request(HTTPRequest::HTTP_GET, "/");
request.set("Authorization", "Bearer s3cr3tt0k3n");
OAuth20Credentials creds(request);
assert (creds.getBearerToken() == "s3cr3tt0k3n");
assertTrue (creds.getBearerToken() == "s3cr3tt0k3n");
}
@@ -65,7 +65,7 @@ void OAuth20CredentialsTest::testExtractCustomScheme()
HTTPRequest request(HTTPRequest::HTTP_GET, "/");
request.set("Authorization", "token s3cr3tt0k3n");
OAuth20Credentials creds(request, "token");
assert (creds.getBearerToken() == "s3cr3tt0k3n");
assertTrue (creds.getBearerToken() == "s3cr3tt0k3n");
}

52
Net/testsuite/src/POP3ClientSessionTest.cpp
View File

@@ -43,12 +43,12 @@ void POP3ClientSessionTest::testLogin()
POP3ClientSession session("127.0.0.1", server.port());
session.login("user", "secret");
std::string cmd = server.popCommand();
assert (cmd == "USER user");
assertTrue (cmd == "USER user");
cmd = server.popCommand();
assert (cmd == "PASS secret");
assertTrue (cmd == "PASS secret");
session.close();
cmd = server.popCommand();
assert (cmd == "QUIT");
assertTrue (cmd == "QUIT");
}
@@ -85,8 +85,8 @@ void POP3ClientSessionTest::testMessageCount()
server.clearCommands();
int n = session.messageCount();
std::string cmd = server.popCommand();
assert (cmd == "STAT");
assert (n == 42);
assertTrue (cmd == "STAT");
assertTrue (n == 42);
session.close();
}
@@ -111,14 +111,14 @@ void POP3ClientSessionTest::testList()
std::vector<POP3ClientSession::MessageInfo> infos;
session.listMessages(infos);
std::string cmd = server.popCommand();
assert (cmd == "LIST");
assert (infos.size() == 3);
assert (infos[0].id == 1);
assert (infos[0].size == 1234);
assert (infos[1].id == 2);
assert (infos[1].size == 5678);
assert (infos[2].id == 3);
assert (infos[2].size == 987);
assertTrue (cmd == "LIST");
assertTrue (infos.size() == 3);
assertTrue (infos[0].id == 1);
assertTrue (infos[0].size == 1234);
assertTrue (infos[1].id == 2);
assertTrue (infos[1].size == 5678);
assertTrue (infos[2].id == 3);
assertTrue (infos[2].size == 987);
session.close();
}
@@ -150,9 +150,9 @@ void POP3ClientSessionTest::testRetrieveMessage()
MailMessage message;
session.retrieveMessage(1, message);
std::string cmd = server.popCommand();
assert (cmd == "RETR 1");
assertTrue (cmd == "RETR 1");
assert (message.getContent() ==
assertTrue (message.getContent() ==
"Hello Jane,\r\n"
"\r\n"
"blah blah blah...\r\n"
@@ -186,10 +186,10 @@ void POP3ClientSessionTest::testRetrieveHeader()
MessageHeader header;
session.retrieveHeader(1, header);
std::string cmd = server.popCommand();
assert (cmd == "TOP 1 0");
assert (header.get("From") == "john.doe@no.where");
assert (header.get("To") == "jane.doe@no.where");
assert (header.get("Subject") == "test");
assertTrue (cmd == "TOP 1 0");
assertTrue (header.get("From") == "john.doe@no.where");
assertTrue (header.get("To") == "jane.doe@no.where");
assertTrue (header.get("Subject") == "test");
session.close();
}
@@ -229,17 +229,17 @@ void POP3ClientSessionTest::testRetrieveMessages()
MessageHeader header;
session.retrieveHeader(1, header);
std::string cmd = server.popCommand();
assert (cmd == "TOP 1 0");
assert (header.get("From") == "john.doe@no.where");
assert (header.get("To") == "jane.doe@no.where");
assert (header.get("Subject") == "test");
assertTrue (cmd == "TOP 1 0");
assertTrue (header.get("From") == "john.doe@no.where");
assertTrue (header.get("To") == "jane.doe@no.where");
assertTrue (header.get("Subject") == "test");
MailMessage message;
session.retrieveMessage(2, message);
cmd = server.popCommand();
assert (cmd == "RETR 2");
assertTrue (cmd == "RETR 2");
assert (message.getContent() ==
assertTrue (message.getContent() ==
"Hello Jane,\r\n"
"\r\n"
"blah blah blah...\r\n"
@@ -264,7 +264,7 @@ void POP3ClientSessionTest::testDeleteMessage()
server.clearCommands();
session.deleteMessage(42);
std::string cmd = server.popCommand();
assert (cmd == "DELE 42");
assertTrue (cmd == "DELE 42");
session.close();
}

42
Net/testsuite/src/PollSetTest.cpp
View File

@@ -57,8 +57,8 @@ void PollSetTest::testPoll()
Stopwatch sw;
sw.start();
Timespan timeout(1000000);
assert (ps.poll(timeout).empty());
assert (sw.elapsed() >= 900000);
assertTrue (ps.poll(timeout).empty());
assertTrue (sw.elapsed() >= 900000);
sw.restart();
ps.add(ss2, PollSet::POLL_READ);
@@ -66,10 +66,10 @@ void PollSetTest::testPoll()
// ss1 must be writable, if polled for
ps.update(ss1, PollSet::POLL_READ | PollSet::POLL_WRITE);
PollSet::SocketModeMap sm = ps.poll(timeout);
assert (sm.find(ss1) != sm.end());
assert (sm.find(ss2) == sm.end());
assert (sm.find(ss1)->second == PollSet::POLL_WRITE);
assert (sw.elapsed() < 100000);
assertTrue (sm.find(ss1) != sm.end());
assertTrue (sm.find(ss2) == sm.end());
assertTrue (sm.find(ss1)->second == PollSet::POLL_WRITE);
assertTrue (sw.elapsed() < 100000);
ps.update(ss1, PollSet::POLL_READ);
@@ -77,38 +77,38 @@ void PollSetTest::testPoll()
char buffer[256];
sw.restart();
sm = ps.poll(timeout);
assert (sm.find(ss1) != sm.end());
assert (sm.find(ss2) == sm.end());
assert (sm.find(ss1)->second == PollSet::POLL_READ);
assert (sw.elapsed() < 100000);
assertTrue (sm.find(ss1) != sm.end());
assertTrue (sm.find(ss2) == sm.end());
assertTrue (sm.find(ss1)->second == PollSet::POLL_READ);
assertTrue (sw.elapsed() < 100000);
int n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss2.sendBytes("HELLO", 5);
sw.restart();
sm = ps.poll(timeout);
assert (sm.find(ss1) == sm.end());
assert (sm.find(ss2) != sm.end());
assert (sm.find(ss2)->second == PollSet::POLL_READ);
assert (sw.elapsed() < 100000);
assertTrue (sm.find(ss1) == sm.end());
assertTrue (sm.find(ss2) != sm.end());
assertTrue (sm.find(ss2)->second == PollSet::POLL_READ);
assertTrue (sw.elapsed() < 100000);
n = ss2.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "HELLO");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "HELLO");
ps.remove(ss2);
ss2.sendBytes("HELLO", 5);
sw.restart();
sm = ps.poll(timeout);
assert (sm.empty());
assertTrue (sm.empty());
n = ss2.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "HELLO");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "HELLO");
ss1.close();
ss2.close();

4
Net/testsuite/src/QuotedPrintableTest.cpp
View File

@@ -43,7 +43,7 @@ void QuotedPrintableTest::testEncode()
"\200\201\r\n";
encoder.close();
std::string txt = ostr.str();
assert (txt == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\r\n"
assertTrue (txt == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\r\n"
"Proin id odio sit amet metus dignissim porttitor.=20\r\n"
"Aliquam nulla ipsum, faucibus non, aliquet quis, aliquet id, felis. Proin s=\r\n"
"odales molestie arcu.\r\n"
@@ -70,7 +70,7 @@ void QuotedPrintableTest::testDecode()
str += (char) c;
c = decoder.get();
}
assert (str == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\r\n"
assertTrue (str == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit.\r\n"
"Proin id odio sit amet metus dignissim porttitor. \r\n"
"Aliquam nulla ipsum, faucibus non, aliquet quis, aliquet id, felis. Proin sodales molestie arcu.\r\n"
"\t\bSed suscipit, mi in facilisis feugiat, \t \r\n"

12
Net/testsuite/src/RawSocketTest.cpp
View File

@@ -48,7 +48,7 @@ void RawSocketTest::testEchoIPv4()
rs.connect(sa);
int n = rs.sendBytes("hello", 5);
assert (5 == n);
assertTrue (5 == n);
char buffer[256] = "";
unsigned char* ptr = (unsigned char*) buffer;
@@ -57,8 +57,8 @@ void RawSocketTest::testEchoIPv4()
int shift = ((buffer[0] & 0x0F) * 4);
ptr += shift;
assert (5 == (n - shift));
assert ("hello" == std::string((char*)ptr, 5));
assertTrue (5 == (n - shift));
assertTrue ("hello" == std::string((char*)ptr, 5));
rs.close();
}
@@ -69,7 +69,7 @@ void RawSocketTest::testSendToReceiveFromIPv4()
RawSocket rs(IPAddress::IPv4);
int n = rs.sendTo("hello", 5, SocketAddress("127.0.0.1", 0));
assert (n == 5);
assertTrue (n == 5);
char buffer[256] = "";
unsigned char* ptr = (unsigned char*) buffer;
@@ -78,8 +78,8 @@ void RawSocketTest::testSendToReceiveFromIPv4()
int shift = ((buffer[0] & 0x0F) * 4);
ptr += shift;
assert ((n - shift) == 5);
assert ("hello" == std::string((char*)ptr, 5));
assertTrue ((n - shift) == 5);
assertTrue ("hello" == std::string((char*)ptr, 5));
rs.close();
}

100
Net/testsuite/src/SMTPClientSessionTest.cpp
View File

@@ -43,10 +43,10 @@ void SMTPClientSessionTest::testLoginEHLO()
SMTPClientSession session("127.0.0.1", server.port());
session.login("localhost");
std::string cmd = server.popCommand();
assert (cmd == "EHLO localhost");
assertTrue (cmd == "EHLO localhost");
session.close();
cmd = server.popCommand();
assert (cmd == "QUIT");
assertTrue (cmd == "QUIT");
}
@@ -60,12 +60,12 @@ void SMTPClientSessionTest::testLoginHELO()
SMTPClientSession session("127.0.0.1", server.port());
session.login("localhost");
std::string cmd = server.popCommand();
assert (cmd == "EHLO localhost");
assertTrue (cmd == "EHLO localhost");
cmd = server.popCommand();
assert (cmd == "HELO localhost");
assertTrue (cmd == "HELO localhost");
session.close();
cmd = server.popCommand();
assert (cmd == "QUIT");
assertTrue (cmd == "QUIT");
}
@@ -108,31 +108,31 @@ void SMTPClientSessionTest::testSend()
server.clearCommands();
session.sendMessage(message);
std::string cmd = server.popCommandWait();
assert (cmd == "MAIL FROM: <john.doe@no.where>");
assertTrue (cmd == "MAIL FROM: <john.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <jane.doe@no.where>");
assertTrue (cmd == "RCPT TO: <jane.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "DATA");
assertTrue (cmd == "DATA");
cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "Date");
assertTrue (cmd.substr(0, 4) == "Date");
cmd = server.popCommandWait();
assert (cmd == "Content-Type: text/plain");
assertTrue (cmd == "Content-Type: text/plain");
cmd = server.popCommandWait();
assert (cmd == "From: john.doe@no.where");
assertTrue (cmd == "From: john.doe@no.where");
cmd = server.popCommandWait();
assert (cmd == "Subject: Test Message");
assertTrue (cmd == "Subject: Test Message");
cmd = server.popCommandWait();
assert (cmd == "Content-Transfer-Encoding: quoted-printable");
assertTrue (cmd == "Content-Transfer-Encoding: quoted-printable");
cmd = server.popCommandWait();
assert (cmd == "To: Jane Doe <jane.doe@no.where>");
assertTrue (cmd == "To: Jane Doe <jane.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "Hello");
assertTrue (cmd == "Hello");
cmd = server.popCommandWait();
assert (cmd == "blah blah");
assertTrue (cmd == "blah blah");
cmd = server.popCommandWait();
assert (cmd == "John");
assertTrue (cmd == "John");
cmd = server.popCommandWait();
assert (cmd == ".");
assertTrue (cmd == ".");
session.close();
}
@@ -167,37 +167,37 @@ void SMTPClientSessionTest::testSendMultiRecipient()
server.clearCommands();
session.sendMessage(message);
std::string cmd = server.popCommandWait();
assert (cmd == "MAIL FROM: <john.doe@no.where>");
assertTrue (cmd == "MAIL FROM: <john.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <jane.doe@no.where>");
assertTrue (cmd == "RCPT TO: <jane.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <jack.doe@no.where>");
assertTrue (cmd == "RCPT TO: <jack.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <joe.doe@no.where>");
assertTrue (cmd == "RCPT TO: <joe.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "DATA");
assertTrue (cmd == "DATA");
cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "Date");
assertTrue (cmd.substr(0, 4) == "Date");
cmd = server.popCommandWait();
assert (cmd == "Content-Type: text/plain");
assertTrue (cmd == "Content-Type: text/plain");
cmd = server.popCommandWait();
assert (cmd == "From: john.doe@no.where");
assertTrue (cmd == "From: john.doe@no.where");
cmd = server.popCommandWait();
assert (cmd == "Subject: Test Message");
assertTrue (cmd == "Subject: Test Message");
cmd = server.popCommandWait();
assert (cmd == "Content-Transfer-Encoding: quoted-printable");
assertTrue (cmd == "Content-Transfer-Encoding: quoted-printable");
cmd = server.popCommandWait();
assert (cmd == "To: Jane Doe <jane.doe@no.where>");
assertTrue (cmd == "To: Jane Doe <jane.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "CC: Jack Doe <jack.doe@no.where>");
assertTrue (cmd == "CC: Jack Doe <jack.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "Hello");
assertTrue (cmd == "Hello");
cmd = server.popCommandWait();
assert (cmd == "blah blah");
assertTrue (cmd == "blah blah");
cmd = server.popCommandWait();
assert (cmd == "John");
assertTrue (cmd == "John");
cmd = server.popCommandWait();
assert (cmd == ".");
assertTrue (cmd == ".");
session.close();
}
@@ -237,37 +237,37 @@ void SMTPClientSessionTest::testMultiSeparateRecipient()
server.clearCommands();
session.sendMessage(message, recipients);
std::string cmd = server.popCommandWait();
assert (cmd == "MAIL FROM: <john.doe@no.where>");
assertTrue (cmd == "MAIL FROM: <john.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <jill.doe@no.where>");
assertTrue (cmd == "RCPT TO: <jill.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <josh.doe@no.where>");
assertTrue (cmd == "RCPT TO: <josh.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "RCPT TO: <jake.doe@no.where>");
assertTrue (cmd == "RCPT TO: <jake.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "DATA");
assertTrue (cmd == "DATA");
cmd = server.popCommandWait();
assert (cmd.substr(0, 4) == "Date");
assertTrue (cmd.substr(0, 4) == "Date");
cmd = server.popCommandWait();
assert (cmd == "Content-Type: text/plain");
assertTrue (cmd == "Content-Type: text/plain");
cmd = server.popCommandWait();
assert (cmd == "From: john.doe@no.where");
assertTrue (cmd == "From: john.doe@no.where");
cmd = server.popCommandWait();
assert (cmd == "Subject: Test Message");
assertTrue (cmd == "Subject: Test Message");
cmd = server.popCommandWait();
assert (cmd == "Content-Transfer-Encoding: quoted-printable");
assertTrue (cmd == "Content-Transfer-Encoding: quoted-printable");
cmd = server.popCommandWait();
assert (cmd == "To: Jane Doe <jane.doe@no.where>");
assertTrue (cmd == "To: Jane Doe <jane.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "CC: Jack Doe <jack.doe@no.where>, Joe Doe <joe.doe@no.where>");
assertTrue (cmd == "CC: Jack Doe <jack.doe@no.where>, Joe Doe <joe.doe@no.where>");
cmd = server.popCommandWait();
assert (cmd == "Hello");
assertTrue (cmd == "Hello");
cmd = server.popCommandWait();
assert (cmd == "blah blah");
assertTrue (cmd == "blah blah");
cmd = server.popCommandWait();
assert (cmd == "John");
assertTrue (cmd == "John");
cmd = server.popCommandWait();
assert (cmd == ".");
assertTrue (cmd == ".");
session.close();
}

84
Net/testsuite/src/SocketAddressTest.cpp
View File

@@ -38,24 +38,24 @@ SocketAddressTest::~SocketAddressTest()
void SocketAddressTest::testSocketAddress()
{
SocketAddress wild;
assert (wild.host().isWildcard());
assert (wild.port() == 0);
assertTrue (wild.host().isWildcard());
assertTrue (wild.port() == 0);
SocketAddress sa1("192.168.1.100", 100);
assert (sa1.af() == AF_INET);
assert (sa1.family() == SocketAddress::IPv4);
assert (sa1.host().toString() == "192.168.1.100");
assert (sa1.port() == 100);
assert (sa1.toString() == "192.168.1.100:100");
assertTrue (sa1.af() == AF_INET);
assertTrue (sa1.family() == SocketAddress::IPv4);
assertTrue (sa1.host().toString() == "192.168.1.100");
assertTrue (sa1.port() == 100);
assertTrue (sa1.toString() == "192.168.1.100:100");
SocketAddress sa2("192.168.1.100", "100");
assert (sa2.host().toString() == "192.168.1.100");
assert (sa2.port() == 100);
assertTrue (sa2.host().toString() == "192.168.1.100");
assertTrue (sa2.port() == 100);
#if !defined(_WIN32_WCE)
SocketAddress sa3("192.168.1.100", "ftp");
assert (sa3.host().toString() == "192.168.1.100");
assert (sa3.port() == 21);
assertTrue (sa3.host().toString() == "192.168.1.100");
assertTrue (sa3.port() == 21);
#endif
try
@@ -68,8 +68,8 @@ void SocketAddressTest::testSocketAddress()
}
SocketAddress sa4("pocoproject.org", 80);
assert (sa4.host().toString() == "162.209.7.4");
assert (sa4.port() == 80);
assertTrue (sa4.host().toString() == "162.209.7.4");
assertTrue (sa4.port() == 80);
try
{
@@ -93,12 +93,12 @@ void SocketAddressTest::testSocketAddress()
}
SocketAddress sa7("192.168.2.120:88");
assert (sa7.host().toString() == "192.168.2.120");
assert (sa7.port() == 88);
assertTrue (sa7.host().toString() == "192.168.2.120");
assertTrue (sa7.port() == 88);
SocketAddress sa8("[192.168.2.120]:88");
assert (sa8.host().toString() == "192.168.2.120");
assert (sa8.port() == 88);
assertTrue (sa8.host().toString() == "192.168.2.120");
assertTrue (sa8.port() == 88);
try
{
@@ -119,16 +119,16 @@ void SocketAddressTest::testSocketAddress()
}
SocketAddress sa10("www6.pocoproject.org", 80);
assert (sa10.host().toString() == "162.209.7.4" || sa10.host().toString() == "[2001:4801:7819:74:be76:4eff:fe10:6b73]");
assertTrue (sa10.host().toString() == "162.209.7.4" || sa10.host().toString() == "[2001:4801:7819:74:be76:4eff:fe10:6b73]");
SocketAddress sa11(SocketAddress::IPv4, "www6.pocoproject.org", 80);
assert (sa11.host().toString() == "162.209.7.4");
assertTrue (sa11.host().toString() == "162.209.7.4");
#ifdef POCO_HAVE_IPv6
try
{
SocketAddress sa12(SocketAddress::IPv6, "www6.pocoproject.org", 80);
assert (sa12.host().toString() == "2001:4801:7819:74:be76:4eff:fe10:6b73");
assertTrue (sa12.host().toString() == "2001:4801:7819:74:be76:4eff:fe10:6b73");
}
catch (AddressFamilyMismatchException&)
{
@@ -142,13 +142,13 @@ void SocketAddressTest::testSocketRelationals()
{
SocketAddress sa1("192.168.1.100", 100);
SocketAddress sa2("192.168.1.100:100");
assert (sa1 == sa2);
assertTrue (sa1 == sa2);
SocketAddress sa3("192.168.1.101", "99");
assert (sa2 < sa3);
assertTrue (sa2 < sa3);
SocketAddress sa4("192.168.1.101", "102");
assert (sa3 < sa4);
assertTrue (sa3 < sa4);
}
@@ -156,18 +156,18 @@ void SocketAddressTest::testSocketAddress6()
{
#ifdef POCO_HAVE_IPv6
SocketAddress sa1("FE80::E6CE:8FFF:FE4A:EDD0", 100);
assert (sa1.af() == AF_INET6);
assert (sa1.family() == SocketAddress::IPv6);
assert (sa1.host().toString() == "fe80::e6ce:8fff:fe4a:edd0");
assert (sa1.port() == 100);
assert (sa1.toString() == "[fe80::e6ce:8fff:fe4a:edd0]:100");
assertTrue (sa1.af() == AF_INET6);
assertTrue (sa1.family() == SocketAddress::IPv6);
assertTrue (sa1.host().toString() == "fe80::e6ce:8fff:fe4a:edd0");
assertTrue (sa1.port() == 100);
assertTrue (sa1.toString() == "[fe80::e6ce:8fff:fe4a:edd0]:100");
SocketAddress sa2("[FE80::E6CE:8FFF:FE4A:EDD0]:100");
assert (sa2.af() == AF_INET6);
assert (sa2.family() == SocketAddress::IPv6);
assert (sa2.host().toString() == "fe80::e6ce:8fff:fe4a:edd0");
assert (sa2.port() == 100);
assert (sa2.toString() == "[fe80::e6ce:8fff:fe4a:edd0]:100");
assertTrue (sa2.af() == AF_INET6);
assertTrue (sa2.family() == SocketAddress::IPv6);
assertTrue (sa2.host().toString() == "fe80::e6ce:8fff:fe4a:edd0");
assertTrue (sa2.port() == 100);
assertTrue (sa2.toString() == "[fe80::e6ce:8fff:fe4a:edd0]:100");
#endif
}
@@ -176,21 +176,21 @@ void SocketAddressTest::testSocketAddressUnixLocal()
{
#ifdef POCO_OS_FAMILY_UNIX
SocketAddress sa1(SocketAddress::UNIX_LOCAL, "/tmp/sock1");
assert (sa1.af() == AF_UNIX);
assert (sa1.family() == SocketAddress::UNIX_LOCAL);
assert (sa1.toString() == "/tmp/sock1");
assertTrue (sa1.af() == AF_UNIX);
assertTrue (sa1.family() == SocketAddress::UNIX_LOCAL);
assertTrue (sa1.toString() == "/tmp/sock1");
SocketAddress sa2(SocketAddress::UNIX_LOCAL, "/tmp/sock2");
assert (sa1 != sa2);
assert (sa1 < sa2);
assertTrue (sa1 != sa2);
assertTrue (sa1 < sa2);
SocketAddress sa3(SocketAddress::UNIX_LOCAL, "/tmp/sock1");
assert (sa1 == sa3);
assert (!(sa1 < sa3));
assertTrue (sa1 == sa3);
assertTrue (!(sa1 < sa3));
SocketAddress sa4("/tmp/sock1");
assert (sa1 == sa4);
assert (sa4.toString() == "/tmp/sock1");
assertTrue (sa1 == sa4);
assertTrue (sa4.toString() == "/tmp/sock1");
#endif
}

34
Net/testsuite/src/SocketReactorTest.cpp
View File

@@ -318,10 +318,10 @@ void SocketReactorTest::testSocketReactor()
ClientServiceHandler::resetData();
reactor.run();
std::string data(ClientServiceHandler::data());
assert (data.size() == 1024);
assert (!ClientServiceHandler::readableError());
assert (!ClientServiceHandler::writableError());
assert (!ClientServiceHandler::timeoutError());
assertTrue (data.size() == 1024);
assertTrue (!ClientServiceHandler::readableError());
assertTrue (!ClientServiceHandler::writableError());
assertTrue (!ClientServiceHandler::timeoutError());
}
@@ -338,10 +338,10 @@ void SocketReactorTest::testSetSocketReactor()
ClientServiceHandler::resetData();
reactor.run();
std::string data(ClientServiceHandler::data());
assert(data.size() == 1024);
assert(!ClientServiceHandler::readableError());
assert(!ClientServiceHandler::writableError());
assert(!ClientServiceHandler::timeoutError());
assertTrue (data.size() == 1024);
assertTrue (!ClientServiceHandler::readableError());
assertTrue (!ClientServiceHandler::writableError());
assertTrue (!ClientServiceHandler::timeoutError());
}
@@ -360,10 +360,10 @@ void SocketReactorTest::testParallelSocketReactor()
ClientServiceHandler::resetData();
reactor.run();
std::string data(ClientServiceHandler::data());
assert (data.size() == 4096);
assert (!ClientServiceHandler::readableError());
assert (!ClientServiceHandler::writableError());
assert (!ClientServiceHandler::timeoutError());
assertTrue (data.size() == 4096);
assertTrue (!ClientServiceHandler::readableError());
assertTrue (!ClientServiceHandler::writableError());
assertTrue (!ClientServiceHandler::timeoutError());
}
@@ -373,11 +373,11 @@ void SocketReactorTest::testSocketConnectorFail()
reactor.setTimeout(Poco::Timespan(3, 0));
SocketAddress sa("192.168.168.192", 12345);
FailConnector connector(sa, reactor);
assert (!connector.failed());
assert (!connector.shutdown());
assertTrue (!connector.failed());
assertTrue (!connector.shutdown());
reactor.run();
assert (connector.failed());
assert (connector.shutdown());
assertTrue (connector.failed());
assertTrue (connector.shutdown());
}
@@ -391,7 +391,7 @@ void SocketReactorTest::testSocketConnectorTimeout()
SocketAddress sa("127.0.0.1", ss.address().port());
SocketConnector<ClientServiceHandler> connector(sa, reactor);
reactor.run();
assert (ClientServiceHandler::timeout());
assertTrue (ClientServiceHandler::timeout());
}

34
Net/testsuite/src/SocketStreamTest.cpp
View File

@@ -50,16 +50,16 @@ void SocketStreamTest::testStreamEcho()
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
SocketStream str(ss);
str << "hello";
assert (str.good());
assertTrue (str.good());
str.flush();
assert (str.good());
assertTrue (str.good());
ss.shutdownSend();
char buffer[5];
str.read(buffer, sizeof(buffer));
assert (str.good());
assert (str.gcount() == 5);
assert (std::string(buffer, 5) == "hello");
assertTrue (str.good());
assertTrue (str.gcount() == 5);
assertTrue (std::string(buffer, 5) == "hello");
ss.close();
}
@@ -76,16 +76,16 @@ void SocketStreamTest::testLargeStreamEcho()
ss.setReceiveBufferSize(msgSize);
std::string payload(msgSize, 'x');
str << payload;
assert (str.good());
assertTrue (str.good());
str.flush();
assert (str.good());
assertTrue (str.good());
ss.shutdownSend();
assert (str.gcount() == 0);
assertTrue (str.gcount() == 0);
char buffer[msgSize];
str.read(buffer, sizeof(buffer));
assert (str.good());
assert (str.gcount() == msgSize);
assertTrue (str.good());
assertTrue (str.gcount() == msgSize);
ss.close();
}
@@ -100,21 +100,21 @@ void SocketStreamTest::testEOF()
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
str << "hello";
assert (str.good());
assertTrue (str.good());
str.flush();
assert (str.good());
assertTrue (str.good());
ss.shutdownSend();
char buffer[5];
str.read(buffer, sizeof(buffer));
assert (str.good());
assert (str.gcount() == 5);
assert (std::string(buffer, 5) == "hello");
assertTrue (str.good());
assertTrue (str.gcount() == 5);
assertTrue (std::string(buffer, 5) == "hello");
}
int c = str.get();
assert (c == -1);
assert (str.eof());
assertTrue (c == -1);
assertTrue (str.eof());
ss.close();
}

182
Net/testsuite/src/SocketTest.cpp
View File

@@ -55,11 +55,11 @@ void SocketTest::testEcho()
StreamSocket ss;
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
int n = ss.sendBytes("hello", 5);
assert (n == 5);
assertTrue (n == 5);
char buffer[256];
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -72,19 +72,19 @@ void SocketTest::testPoll()
Stopwatch sw;
sw.start();
Timespan timeout(1000000);
assert (!ss.poll(timeout, Socket::SELECT_READ));
assert (sw.elapsed() >= 900000);
assertTrue (!ss.poll(timeout, Socket::SELECT_READ));
assertTrue (sw.elapsed() >= 900000);
sw.restart();
assert (ss.poll(timeout, Socket::SELECT_WRITE));
assert (sw.elapsed() < 100000);
assertTrue (ss.poll(timeout, Socket::SELECT_WRITE));
assertTrue (sw.elapsed() < 100000);
ss.sendBytes("hello", 5);
char buffer[256];
sw.restart();
assert (ss.poll(timeout, Socket::SELECT_READ));
assert (sw.elapsed() < 100000);
assertTrue (ss.poll(timeout, Socket::SELECT_READ));
assertTrue (sw.elapsed() < 100000);
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -97,12 +97,12 @@ void SocketTest::testAvailable()
Timespan timeout(1000000);
ss.sendBytes("hello", 5);
char buffer[256];
assert (ss.poll(timeout, Socket::SELECT_READ));
assertTrue (ss.poll(timeout, Socket::SELECT_READ));
int av = ss.available();
assert (av > 0 && av <= 5);
assertTrue (av > 0 && av <= 5);
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -121,40 +121,40 @@ void SocketTest::testFIFOBuffer()
f.readable += delegate(this, &SocketTest::onReadable);
f.writable += delegate(this, &SocketTest::onWritable);
assert(0 == _notToReadable);
assert(0 == _readableToNot);
assert(0 == _notToWritable);
assert(0 == _writableToNot);
assertTrue (0 == _notToReadable);
assertTrue (0 == _readableToNot);
assertTrue (0 == _notToWritable);
assertTrue (0 == _writableToNot);
f.write(b);
assert(1 == _notToReadable);
assert(0 == _readableToNot);
assert(0 == _notToWritable);
assert(1 == _writableToNot);
assertTrue (1 == _notToReadable);
assertTrue (0 == _readableToNot);
assertTrue (0 == _notToWritable);
assertTrue (1 == _writableToNot);
EchoServer echoServer;
StreamSocket ss;
ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
int n = ss.sendBytes(f);
assert (n == 5);
assert(1 == _notToReadable);
assert(1 == _readableToNot);
assert(1 == _notToWritable);
assert(1 == _writableToNot);
assert (f.isEmpty());
assertTrue (n == 5);
assertTrue (1 == _notToReadable);
assertTrue (1 == _readableToNot);
assertTrue (1 == _notToWritable);
assertTrue (1 == _writableToNot);
assertTrue (f.isEmpty());
n = ss.receiveBytes(f);
assert (n == 5);
assertTrue (n == 5);
assert(2 == _notToReadable);
assert(1 == _readableToNot);
assert(1 == _notToWritable);
assert(2 == _writableToNot);
assertTrue (2 == _notToReadable);
assertTrue (1 == _readableToNot);
assertTrue (1 == _notToWritable);
assertTrue (2 == _writableToNot);
assert (f[0] == 'h');
assert (f[1] == 'e');
assert (f[2] == 'l');
assert (f[3] == 'l');
assert (f[4] == 'o');
assertTrue (f[0] == 'h');
assertTrue (f[1] == 'e');
assertTrue (f[2] == 'l');
assertTrue (f[3] == 'l');
assertTrue (f[4] == 'o');
f.readable -= delegate(this, &SocketTest::onReadable);
f.writable -= delegate(this, &SocketTest::onWritable);
@@ -225,15 +225,15 @@ void SocketTest::testNonBlocking()
ss.setBlocking(false);
Timespan timeout(1000000);
assert (ss.poll(timeout, Socket::SELECT_WRITE));
assertTrue (ss.poll(timeout, Socket::SELECT_WRITE));
int n = ss.sendBytes("hello", 5);
assert (n == 5);
assertTrue (n == 5);
char buffer[256];
assert (ss.poll(timeout, Socket::SELECT_READ));
assertTrue (ss.poll(timeout, Socket::SELECT_READ));
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -247,8 +247,8 @@ void SocketTest::testAddress()
StreamSocket ss;
ss.connect(SocketAddress("127.0.0.1", serv.address().port()));
StreamSocket css = serv.acceptConnection();
assert (css.peerAddress().host() == ss.address().host());
assert (css.peerAddress().port() == ss.address().port());
assertTrue (css.peerAddress().host() == ss.address().host());
assertTrue (css.peerAddress().port() == ss.address().port());
}
@@ -258,12 +258,12 @@ void SocketTest::testAssign()
StreamSocket ss1;
StreamSocket ss2;
assert (ss1 != ss2);
assertTrue (ss1 != ss2);
StreamSocket ss3(ss1);
assert (ss1 == ss3);
assertTrue (ss1 == ss3);
ss3 = ss2;
assert (ss1 != ss3);
assert (ss2 == ss3);
assertTrue (ss1 != ss3);
assertTrue (ss2 == ss3);
try
{
@@ -318,7 +318,7 @@ void SocketTest::testTimeout()
std::cout << "actual receive timeout: " << timeout1.totalMicroseconds() << std::endl;
// some socket implementations adjust the timeout value
// assert (ss.getReceiveTimeout() == timeout);
// assertTrue (ss.getReceiveTimeout() == timeout);
Stopwatch sw;
try
{
@@ -330,7 +330,7 @@ void SocketTest::testTimeout()
catch (TimeoutException&)
{
}
assert (sw.elapsed() < 1000000);
assertTrue (sw.elapsed() < 1000000);
timeout0 = ss.getSendTimeout();
ss.setSendTimeout(timeout);
@@ -338,7 +338,7 @@ void SocketTest::testTimeout()
std::cout << "original send timeout: " << timeout0.totalMicroseconds() << std::endl;
std::cout << "requested send timeout: " << timeout.totalMicroseconds() << std::endl;
std::cout << "actual send timeout: " << timeout1.totalMicroseconds() << std::endl;
// assert (ss.getSendTimeout() == timeout);
// assertTrue (ss.getSendTimeout() == timeout);
}
@@ -375,25 +375,25 @@ void SocketTest::testOptions()
bool f;
int t;
ss.getLinger(f, t);
assert (f && t == 20);
assertTrue (f && t == 20);
ss.setLinger(false, 0);
ss.getLinger(f, t);
assert (!f);
assertTrue (!f);
ss.setNoDelay(true);
assert (ss.getNoDelay());
assertTrue (ss.getNoDelay());
ss.setNoDelay(false);
assert (!ss.getNoDelay());
assertTrue (!ss.getNoDelay());
ss.setKeepAlive(true);
assert (ss.getKeepAlive());
assertTrue (ss.getKeepAlive());
ss.setKeepAlive(false);
assert (!ss.getKeepAlive());
assertTrue (!ss.getKeepAlive());
ss.setOOBInline(true);
assert (ss.getOOBInline());
assertTrue (ss.getOOBInline());
ss.setOOBInline(false);
assert (!ss.getOOBInline());
assertTrue (!ss.getOOBInline());
}
@@ -410,10 +410,10 @@ void SocketTest::testSelect()
Socket::SocketList exceptList;
readList.push_back(ss);
assert (Socket::select(readList, writeList, exceptList, timeout) == 0);
assert (readList.empty());
assert (writeList.empty());
assert (exceptList.empty());
assertTrue (Socket::select(readList, writeList, exceptList, timeout) == 0);
assertTrue (readList.empty());
assertTrue (writeList.empty());
assertTrue (exceptList.empty());
ss.sendBytes("hello", 5);
@@ -421,15 +421,15 @@ void SocketTest::testSelect()
readList.push_back(ss);
writeList.push_back(ss);
assert (Socket::select(readList, writeList, exceptList, timeout) == 2);
assert (!readList.empty());
assert (!writeList.empty());
assert (exceptList.empty());
assertTrue (Socket::select(readList, writeList, exceptList, timeout) == 2);
assertTrue (!readList.empty());
assertTrue (!writeList.empty());
assertTrue (exceptList.empty());
char buffer[256];
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
}
@@ -449,10 +449,10 @@ void SocketTest::testSelect2()
readList.push_back(ss1);
readList.push_back(ss2);
assert (Socket::select(readList, writeList, exceptList, timeout) == 0);
assert (readList.empty());
assert (writeList.empty());
assert (exceptList.empty());
assertTrue (Socket::select(readList, writeList, exceptList, timeout) == 0);
assertTrue (readList.empty());
assertTrue (writeList.empty());
assertTrue (exceptList.empty());
ss1.sendBytes("hello", 5);
@@ -460,28 +460,28 @@ void SocketTest::testSelect2()
readList.push_back(ss1);
readList.push_back(ss2);
assert (Socket::select(readList, writeList, exceptList, timeout) == 1);
assertTrue (Socket::select(readList, writeList, exceptList, timeout) == 1);
assert (readList.size() == 1);
assert (readList[0] == ss1);
assert (writeList.empty());
assert (exceptList.empty());
assertTrue (readList.size() == 1);
assertTrue (readList[0] == ss1);
assertTrue (writeList.empty());
assertTrue (exceptList.empty());
char buffer[256];
int n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assertTrue (n == 5);
readList.clear();
writeList.clear();
exceptList.clear();
writeList.push_back(ss1);
writeList.push_back(ss2);
assert (Socket::select(readList, writeList, exceptList, timeout) == 2);
assert (readList.empty());
assert (writeList.size() == 2);
assert (writeList[0] == ss1);
assert (writeList[1] == ss2);
assert (exceptList.empty());
assertTrue (Socket::select(readList, writeList, exceptList, timeout) == 2);
assertTrue (readList.empty());
assertTrue (writeList.size() == 2);
assertTrue (writeList[0] == ss1);
assertTrue (writeList[1] == ss2);
assertTrue (exceptList.empty());
ss1.close();
ss2.close();
@@ -496,7 +496,7 @@ void SocketTest::testSelect3()
Timespan timeout(1000);
int rc = Socket::select(readList, writeList, exceptList, timeout);
assert (rc == 0);
assertTrue (rc == 0);
}
@@ -514,11 +514,11 @@ void SocketTest::testEchoUnixLocal()
StreamSocket ss(SocketAddress::UNIX_LOCAL);
ss.connect(localAddr);
int n = ss.sendBytes("hello", 5);
assert (n == 5);
assertTrue (n == 5);
char buffer[256];
n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 5);
assert (std::string(buffer, n) == "hello");
assertTrue (n == 5);
assertTrue (std::string(buffer, n) == "hello");
ss.close();
socketFile.remove();
#endif

66
Net/testsuite/src/SyslogTest.cpp
View File

@@ -129,19 +129,19 @@ void SyslogTest::testListener()
listener->open();
CachingChannel cl;
listener->addChannel(&cl);
assert (cl.getCurrentSize() == 0);
assertTrue (cl.getCurrentSize() == 0);
Poco::Message msg("asource", "amessage", Poco::Message::PRIO_CRITICAL);
channel->log(msg);
Poco::Thread::sleep(1000);
listener->close();
channel->close();
assert (cl.getCurrentSize() == 1);
assertTrue (cl.getCurrentSize() == 1);
std::vector<Poco::Message> msgs;
cl.getMessages(msgs, 0, 10);
assert (msgs.size() == 1);
assert (msgs[0].getSource() == "asource");
assert (msgs[0].getText() == "amessage");
assert (msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
assertTrue (msgs.size() == 1);
assertTrue (msgs[0].getSource() == "asource");
assertTrue (msgs[0].getText() == "amessage");
assertTrue (msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
}
@@ -155,11 +155,11 @@ void SyslogTest::testChannelOpenClose()
CachingChannel cl;
listener->addChannel(&cl);
assert (cl.getCurrentSize() == 0);
assertTrue (cl.getCurrentSize() == 0);
Poco::Message msg1("source1", "message1", Poco::Message::PRIO_CRITICAL);
channel->log(msg1);
Poco::Thread::sleep(1000);
assert (cl.getCurrentSize() == 1);
assertTrue (cl.getCurrentSize() == 1);
channel->close(); // close and re-open channel
channel->open();
@@ -167,20 +167,20 @@ void SyslogTest::testChannelOpenClose()
Poco::Message msg2("source2", "message2", Poco::Message::PRIO_ERROR);
channel->log(msg2);
Poco::Thread::sleep(1000);
assert (cl.getCurrentSize() == 2);
assertTrue (cl.getCurrentSize() == 2);
listener->close();
std::vector<Poco::Message> msgs;
cl.getMessages(msgs, 0, 10);
assert (msgs.size() == 2);
assertTrue (msgs.size() == 2);
assert (msgs[1].getSource() == "source1");
assert (msgs[1].getText() == "message1");
assert (msgs[1].getPriority() == Poco::Message::PRIO_CRITICAL);
assertTrue (msgs[1].getSource() == "source1");
assertTrue (msgs[1].getText() == "message1");
assertTrue (msgs[1].getPriority() == Poco::Message::PRIO_CRITICAL);
assert (msgs[0].getSource() == "source2");
assert (msgs[0].getText() == "message2");
assert (msgs[0].getPriority() == Poco::Message::PRIO_ERROR);
assertTrue (msgs[0].getSource() == "source2");
assertTrue (msgs[0].getText() == "message2");
assertTrue (msgs[0].getPriority() == Poco::Message::PRIO_ERROR);
}
@@ -194,20 +194,20 @@ void SyslogTest::testOldBSD()
listener->open();
CachingChannel cl;
listener->addChannel(&cl);
assert (cl.getCurrentSize() == 0);
assertTrue (cl.getCurrentSize() == 0);
Poco::Message msg("asource", "amessage", Poco::Message::PRIO_CRITICAL);
channel->log(msg);
Poco::Thread::sleep(1000);
listener->close();
channel->close();
assert (cl.getCurrentSize() == 1);
assertTrue (cl.getCurrentSize() == 1);
std::vector<Poco::Message> msgs;
cl.getMessages(msgs, 0, 10);
assert (msgs.size() == 1);
assertTrue (msgs.size() == 1);
// the source is lost with old BSD messages: we only send the local host name!
assert (msgs[0].getSource() == Poco::Net::DNS::thisHost().name());
assert (msgs[0].getText() == "amessage");
assert (msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
assertTrue (msgs[0].getSource() == Poco::Net::DNS::thisHost().name());
assertTrue (msgs[0].getText() == "amessage");
assertTrue (msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
}
@@ -220,7 +220,7 @@ void SyslogTest::testStructuredData()
listener->open();
CachingChannel cl;
listener->addChannel(&cl);
assert(cl.getCurrentSize() == 0);
assertTrue (cl.getCurrentSize() == 0);
Poco::Message msg1("asource", "amessage", Poco::Message::PRIO_CRITICAL);
msg1.set("structured-data", "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"]");
channel->log(msg1);
@@ -230,20 +230,20 @@ void SyslogTest::testStructuredData()
Poco::Thread::sleep(1000);
listener->close();
channel->close();
assert(cl.getCurrentSize() == 2);
assertTrue (cl.getCurrentSize() == 2);
std::vector<Poco::Message> msgs;
cl.getMessages(msgs, 0, 10);
assert(msgs.size() == 2);
assertTrue (msgs.size() == 2);
assert(msgs[0].getSource() == "asource");
assert(msgs[0].getText() == "amessage");
assert(msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
assert(msgs[0].get("structured-data") == "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"][examplePriority@32473 class=\"high\"]");
assertTrue (msgs[0].getSource() == "asource");
assertTrue (msgs[0].getText() == "amessage");
assertTrue (msgs[0].getPriority() == Poco::Message::PRIO_CRITICAL);
assertTrue (msgs[0].get("structured-data") == "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"][examplePriority@32473 class=\"high\"]");
assert(msgs[1].getSource() == "asource");
assert(msgs[1].getText() == "amessage");
assert(msgs[1].getPriority() == Poco::Message::PRIO_CRITICAL);
assert(msgs[1].get("structured-data") == "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"]");
assertTrue (msgs[1].getSource() == "asource");
assertTrue (msgs[1].getText() == "amessage");
assertTrue (msgs[1].getPriority() == Poco::Message::PRIO_CRITICAL);
assertTrue (msgs[1].get("structured-data") == "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"]");
}

148
Net/testsuite/src/TCPServerTest.cpp
View File

@@ -87,10 +87,10 @@ void TCPServerTest::testOneConnection()
{
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>());
srv.start();
assert (srv.currentConnections() == 0);
assert (srv.currentThreads() == 0);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 0);
assertTrue (srv.currentConnections() == 0);
assertTrue (srv.currentThreads() == 0);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 0);
SocketAddress sa("127.0.0.1", srv.socket().address().port());
StreamSocket ss1(sa);
@@ -98,15 +98,15 @@ void TCPServerTest::testOneConnection()
ss1.sendBytes(data.data(), (int) data.size());
char buffer[256];
int n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assert (srv.currentConnections() == 1);
assert (srv.currentThreads() == 1);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 1);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assertTrue (srv.currentConnections() == 1);
assertTrue (srv.currentThreads() == 1);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 1);
ss1.close();
Thread::sleep(1000);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -114,10 +114,10 @@ void TCPServerTest::testTwoConnections()
{
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>());
srv.start();
assert (srv.currentConnections() == 0);
assert (srv.currentThreads() == 0);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 0);
assertTrue (srv.currentConnections() == 0);
assertTrue (srv.currentThreads() == 0);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 0);
SocketAddress sa("127.0.0.1", srv.socket().address().port());
StreamSocket ss1(sa);
@@ -128,27 +128,27 @@ void TCPServerTest::testTwoConnections()
char buffer[256];
int n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
n = ss2.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assert (srv.currentConnections() == 2);
assert (srv.currentThreads() == 2);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 2);
assertTrue (srv.currentConnections() == 2);
assertTrue (srv.currentThreads() == 2);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 2);
ss1.close();
Thread::sleep(1000);
assert (srv.currentConnections() == 1);
assert (srv.currentThreads() == 1);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 2);
assertTrue (srv.currentConnections() == 1);
assertTrue (srv.currentThreads() == 1);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 2);
ss2.close();
Thread::sleep(1000);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -161,11 +161,11 @@ void TCPServerTest::testMultiConnections()
pParams->setThreadIdleTime(100);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs, pParams);
srv.start();
assert (srv.currentConnections() == 0);
assert (srv.currentThreads() == 0);
assert (srv.maxThreads() >= 4);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 0);
assertTrue (srv.currentConnections() == 0);
assertTrue (srv.currentThreads() == 0);
assertTrue (srv.maxThreads() >= 4);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 0);
SocketAddress sa("127.0.0.1", svs.address().port());
StreamSocket ss1(sa);
@@ -180,65 +180,65 @@ void TCPServerTest::testMultiConnections()
char buffer[256];
int n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
n = ss2.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
n = ss3.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
n = ss4.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assert (srv.currentConnections() == 4);
assert (srv.currentThreads() == 4);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 4);
assertTrue (srv.currentConnections() == 4);
assertTrue (srv.currentThreads() == 4);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 4);
StreamSocket ss5(sa);
Thread::sleep(200);
assert (srv.queuedConnections() == 1);
assertTrue (srv.queuedConnections() == 1);
StreamSocket ss6(sa);
Thread::sleep(200);
assert (srv.queuedConnections() == 2);
assertTrue (srv.queuedConnections() == 2);
ss1.close();
Thread::sleep(2000);
assert (srv.currentConnections() == 4);
assert (srv.currentThreads() == 4);
assert (srv.queuedConnections() == 1);
assert (srv.totalConnections() == 5);
assertTrue (srv.currentConnections() == 4);
assertTrue (srv.currentThreads() == 4);
assertTrue (srv.queuedConnections() == 1);
assertTrue (srv.totalConnections() == 5);
ss2.close();
Thread::sleep(2000);
assert (srv.currentConnections() == 4);
assert (srv.currentThreads() == 4);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 6);
assertTrue (srv.currentConnections() == 4);
assertTrue (srv.currentThreads() == 4);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 6);
ss3.close();
Thread::sleep(2000);
assert (srv.currentConnections() == 3);
assert (srv.currentThreads() == 3);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 6);
assertTrue (srv.currentConnections() == 3);
assertTrue (srv.currentThreads() == 3);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 6);
ss4.close();
Thread::sleep(2000);
assert (srv.currentConnections() == 2);
assert (srv.currentThreads() == 2);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 6);
assertTrue (srv.currentConnections() == 2);
assertTrue (srv.currentThreads() == 2);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 6);
ss5.close();
ss6.close();
Thread::sleep(1000);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -249,7 +249,7 @@ void TCPServerTest::testThreadCapacity()
pParams->setMaxThreads(64);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs, pParams);
srv.start();
assert (srv.maxThreads() >= 64);
assertTrue (srv.maxThreads() >= 64);
}
@@ -258,10 +258,10 @@ void TCPServerTest::testFilter()
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>());
srv.setConnectionFilter(new RejectFilter);
srv.start();
assert (srv.currentConnections() == 0);
assert (srv.currentThreads() == 0);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 0);
assertTrue (srv.currentConnections() == 0);
assertTrue (srv.currentThreads() == 0);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 0);
SocketAddress sa("127.0.0.1", srv.socket().address().port());
StreamSocket ss(sa);
@@ -269,11 +269,11 @@ void TCPServerTest::testFilter()
char buffer[256];
int n = ss.receiveBytes(buffer, sizeof(buffer));
assert (n == 0);
assert (srv.currentConnections() == 0);
assert (srv.currentThreads() == 0);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 0);
assertTrue (n == 0);
assertTrue (srv.currentConnections() == 0);
assertTrue (srv.currentThreads() == 0);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 0);
}

58
Net/testsuite/src/WebSocketTest.cpp
View File

@@ -128,25 +128,25 @@ void WebSocketTest::testWebSocket()
char buffer[1024];
int flags;
int n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
for (int i = 2; i < 20; i++)
{
payload.assign(i, 'x');
ws.sendFrame(payload.data(), (int) payload.size());
n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
ws.sendFrame(payload.data(), (int) payload.size());
Poco::Buffer<char> pocobuffer(0);
n = ws.receiveFrame(pocobuffer, flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
}
for (int i = 125; i < 129; i++)
@@ -154,36 +154,36 @@ void WebSocketTest::testWebSocket()
payload.assign(i, 'x');
ws.sendFrame(payload.data(), (int) payload.size());
n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
ws.sendFrame(payload.data(), (int) payload.size());
Poco::Buffer<char> pocobuffer(0);
n = ws.receiveFrame(pocobuffer, flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
}
payload = "Hello, world!";
ws.sendFrame(payload.data(), (int) payload.size());
n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assert (flags == WebSocket::FRAME_TEXT);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_TEXT);
payload = "Hello, universe!";
ws.sendFrame(payload.data(), (int) payload.size(), WebSocket::FRAME_BINARY);
n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assert (flags == WebSocket::FRAME_BINARY);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (flags == WebSocket::FRAME_BINARY);
ws.shutdown();
n = ws.receiveFrame(buffer, sizeof(buffer), flags);
assert (n == 2);
assert ((flags & WebSocket::FRAME_OP_BITMASK) == WebSocket::FRAME_OP_CLOSE);
assertTrue (n == 2);
assertTrue ((flags & WebSocket::FRAME_OP_BITMASK) == WebSocket::FRAME_OP_CLOSE);
server.stop();
}
@@ -218,8 +218,8 @@ void WebSocketTest::testWebSocketLarge()
n += ws.receiveFrame(buffer + n, sizeof(buffer) - n, flags);
} while (n > 0 && n < msgSize);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer, 0, n) == 0);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
}
@@ -246,16 +246,16 @@ void WebSocketTest::testOneLargeFrame(int msgSize)
int n;
n = ws.receiveFrame(buffer.begin(), buffer.size(), flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), buffer.begin(), 0, n) == 0);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), buffer.begin(), 0, n) == 0);
ws.sendFrame(payload.data(), msgSize);
Poco::Buffer<char> pocobuffer(0);
n = ws.receiveFrame(pocobuffer, flags);
assert (n == payload.size());
assert (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
assertTrue (n == payload.size());
assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
}