generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-20 05:49:04 +02: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

126
NetSSL_OpenSSL/testsuite/src/HTTPSClientSessionTest.cpp
View File

@@ -95,11 +95,11 @@ void HTTPSClientSessionTest::testGetSmall()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr.str() == HTTPSTestServer::SMALL_BODY);
}
@@ -111,11 +111,11 @@ void HTTPSClientSessionTest::testGetLarge()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPSTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPSTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPSTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPSTestServer::LARGE_BODY);
}
@@ -127,10 +127,10 @@ void HTTPSClientSessionTest::testHead()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPSTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPSTestServer::LARGE_BODY.length());
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
assert (StreamCopier::copyStream(rs, ostr) == 0);
assertTrue (StreamCopier::copyStream(rs, ostr) == 0);
}
@@ -144,10 +144,10 @@ void HTTPSClientSessionTest::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);
}
@@ -162,10 +162,10 @@ void HTTPSClientSessionTest::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);
}
@@ -179,11 +179,11 @@ void HTTPSClientSessionTest::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);
}
@@ -197,11 +197,11 @@ void HTTPSClientSessionTest::testPostLargeChunked()
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);
}
@@ -222,11 +222,11 @@ void HTTPSClientSessionTest::testPostLargeChunkedKeepAlive()
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);
}
srv.stop();
}
@@ -247,42 +247,42 @@ void HTTPSClientSessionTest::testKeepAlive()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs1 = s.receiveResponse(response);
assert (response.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response.getContentType() == "text/plain");
assert (response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPSTestServer::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() == HTTPSTestServer::SMALL_BODY.length());
assert (response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response.getKeepAlive());
std::ostringstream ostr2;
StreamCopier::copyStream(rs2, ostr2);
assert (ostr2.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr2.str() == HTTPSTestServer::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() == HTTPSTestServer::LARGE_BODY);
assertTrue (ostr3.str() == HTTPSTestServer::LARGE_BODY);
request.setMethod(HTTPRequest::HTTP_HEAD);
request.setURI("/large");
s.sendRequest(request);
std::istream& rs4 = s.receiveResponse(response);
assert (response.getContentLength() == HTTPSTestServer::LARGE_BODY.length());
assert (response.getContentType() == "text/plain");
assert (!response.getKeepAlive());
assertTrue (response.getContentLength() == HTTPSTestServer::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);
}
@@ -297,8 +297,8 @@ void HTTPSClientSessionTest::testInterop()
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
std::string str(ostr.str());
assert (str == "This is a test file for NetSSL.\n");
assert (cert.commonName() == "secure.appinf.com" || cert.commonName() == "*.appinf.com");
assertTrue (str == "This is a test file for NetSSL.\n");
assertTrue (cert.commonName() == "secure.appinf.com" || cert.commonName() == "*.appinf.com");
}
@@ -318,8 +318,8 @@ void HTTPSClientSessionTest::testProxy()
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
std::string str(ostr.str());
assert (str == "This is a test file for NetSSL.\n");
assert (cert.commonName() == "secure.appinf.com" || cert.commonName() == "*.appinf.com");
assertTrue (str == "This is a test file for NetSSL.\n");
assertTrue (cert.commonName() == "secure.appinf.com" || cert.commonName() == "*.appinf.com");
}
@@ -362,11 +362,11 @@ void HTTPSClientSessionTest::testCachedSession()
Session::Ptr pSession1 = s1.sslSession();
HTTPResponse response1;
std::istream& rs1 = s1.receiveResponse(response1);
assert (response1.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response1.getContentType() == "text/plain");
assertTrue (response1.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response1.getContentType() == "text/plain");
std::ostringstream ostr1;
StreamCopier::copyStream(rs1, ostr1);
assert (ostr1.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr1.str() == HTTPSTestServer::SMALL_BODY);
HTTPSClientSession s2("127.0.0.1", srv.port(), pClientContext, pSession1);
HTTPRequest request2(HTTPRequest::HTTP_GET, "/small");
@@ -374,26 +374,26 @@ void HTTPSClientSessionTest::testCachedSession()
Session::Ptr pSession2 = s2.sslSession();
HTTPResponse response2;
std::istream& rs2 = s2.receiveResponse(response2);
assert (response2.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response2.getContentType() == "text/plain");
assertTrue (response2.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response2.getContentType() == "text/plain");
std::ostringstream ostr2;
StreamCopier::copyStream(rs2, ostr2);
assert (ostr2.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr2.str() == HTTPSTestServer::SMALL_BODY);
assert (pSession1 == pSession2);
assertTrue (pSession1 == pSession2);
HTTPRequest request3(HTTPRequest::HTTP_GET, "/small");
s2.sendRequest(request3);
Session::Ptr pSession3 = s2.sslSession();
HTTPResponse response3;
std::istream& rs3 = s2.receiveResponse(response3);
assert (response3.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response3.getContentType() == "text/plain");
assertTrue (response3.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response3.getContentType() == "text/plain");
std::ostringstream ostr3;
StreamCopier::copyStream(rs3, ostr3);
assert (ostr3.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr3.str() == HTTPSTestServer::SMALL_BODY);
assert (pSession1 == pSession3);
assertTrue (pSession1 == pSession3);
Thread::sleep(15000); // wait for session to expire
pServerContext->flushSessionCache();
@@ -403,13 +403,13 @@ void HTTPSClientSessionTest::testCachedSession()
Session::Ptr pSession4 = s2.sslSession();
HTTPResponse response4;
std::istream& rs4 = s2.receiveResponse(response4);
assert (response4.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assert (response4.getContentType() == "text/plain");
assertTrue (response4.getContentLength() == HTTPSTestServer::SMALL_BODY.length());
assertTrue (response4.getContentType() == "text/plain");
std::ostringstream ostr4;
StreamCopier::copyStream(rs4, ostr4);
assert (ostr4.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr4.str() == HTTPSTestServer::SMALL_BODY);
assert (pSession1 != pSession4);
assertTrue (pSession1 != pSession4);
}
@@ -421,11 +421,11 @@ void HTTPSClientSessionTest::testUnknownContentLength()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr.str() == HTTPSTestServer::SMALL_BODY);
}
@@ -437,12 +437,12 @@ void HTTPSClientSessionTest::testServerAbort()
s.sendRequest(request);
HTTPResponse response;
std::istream& rs = s.receiveResponse(response);
assert (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assert (response.getContentType() == "text/plain");
assertTrue (response.getContentLength() == HTTPMessage::UNKNOWN_CONTENT_LENGTH);
assertTrue (response.getContentType() == "text/plain");
std::ostringstream ostr;
StreamCopier::copyStream(rs, ostr);
assert (ostr.str() == HTTPSTestServer::SMALL_BODY);
assert ( dynamic_cast<const Poco::Net::SSLConnectionUnexpectedlyClosedException*>(
assertTrue (ostr.str() == HTTPSTestServer::SMALL_BODY);
assertTrue ( dynamic_cast<const Poco::Net::SSLConnectionUnexpectedlyClosedException*>(
s.networkException()) != NULL );
}

70
NetSSL_OpenSSL/testsuite/src/HTTPSServerTest.cpp
View File

@@ -140,9 +140,9 @@ void HTTPSServerTest::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);
}
@@ -163,10 +163,10 @@ void HTTPSServerTest::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);
}
@@ -188,20 +188,20 @@ void HTTPSServerTest::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 HTTPSServerTest::testChunkedRequestKeepAlive()
@@ -222,20 +222,20 @@ void HTTPSServerTest::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);
}
@@ -257,9 +257,9 @@ void HTTPSServerTest::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);
}
@@ -277,9 +277,9 @@ void HTTPSServerTest::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());
}
@@ -297,9 +297,9 @@ void HTTPSServerTest::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());
}
@@ -317,8 +317,8 @@ void HTTPSServerTest::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());
}

8
NetSSL_OpenSSL/testsuite/src/HTTPSStreamFactoryTest.cpp
View File

@@ -54,7 +54,7 @@ void HTTPSStreamFactoryTest::testNoRedirect()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPSTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPSTestServer::LARGE_BODY);
}
@@ -71,7 +71,7 @@ void HTTPSStreamFactoryTest::testEmptyPath()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPSTestServer::SMALL_BODY);
assertTrue (ostr.str() == HTTPSTestServer::SMALL_BODY);
}
@@ -88,7 +88,7 @@ void HTTPSStreamFactoryTest::testRedirect()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str() == HTTPSTestServer::LARGE_BODY);
assertTrue (ostr.str() == HTTPSTestServer::LARGE_BODY);
}
@@ -107,7 +107,7 @@ void HTTPSStreamFactoryTest::testProxy()
#endif // POCO_ENABLE_CPP11
std::ostringstream ostr;
StreamCopier::copyStream(*pStr.get(), ostr);
assert (ostr.str().length() > 0);
assertTrue (ostr.str().length() > 0);
}

216
NetSSL_OpenSSL/testsuite/src/TCPServerTest.cpp
View File

@@ -88,10 +88,10 @@ void TCPServerTest::testOneConnection()
SecureServerSocket svs(0);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs);
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", svs.address().port());
SecureStreamSocket ss1(sa);
@@ -99,15 +99,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(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -116,10 +116,10 @@ void TCPServerTest::testTwoConnections()
SecureServerSocket svs(0);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs);
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", svs.address().port());
SecureStreamSocket ss1(sa);
@@ -130,27 +130,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(300);
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(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -163,10 +163,10 @@ 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.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", svs.address().port());
SecureStreamSocket ss1(sa);
@@ -181,69 +181,69 @@ 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);
SecureStreamSocket ss5;
ss5.setLazyHandshake();
ss5.connect(sa);
Thread::sleep(200);
assert (srv.queuedConnections() == 1);
assertTrue (srv.queuedConnections() == 1);
SecureStreamSocket ss6;
ss6.setLazyHandshake();
ss6.connect(sa);
Thread::sleep(200);
assert (srv.queuedConnections() == 2);
assertTrue (srv.queuedConnections() == 2);
ss1.close();
Thread::sleep(300);
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(300);
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(300);
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(300);
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(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -252,10 +252,10 @@ void TCPServerTest::testReuseSocket()
SecureServerSocket svs(0);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs);
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", svs.address().port());
SecureStreamSocket ss1(sa);
@@ -263,27 +263,27 @@ void TCPServerTest::testReuseSocket()
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(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
ss1.connect(sa);
ss1.sendBytes(data.data(), (int) data.size());
n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assert (srv.currentConnections() == 1);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 2);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assertTrue (srv.currentConnections() == 1);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 2);
ss1.close();
Thread::sleep(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}
@@ -310,10 +310,10 @@ void TCPServerTest::testReuseSession()
SecureServerSocket svs(0, 64, pServerContext);
TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>(), svs);
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);
Context::Ptr pClientContext = new Context(
Context::CLIENT_USE,
@@ -328,56 +328,56 @@ void TCPServerTest::testReuseSession()
SocketAddress sa("127.0.0.1", svs.address().port());
SecureStreamSocket ss1(sa, pClientContext);
assert (!ss1.sessionWasReused());
assertTrue (!ss1.sessionWasReused());
std::string data("hello, world");
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);
Session::Ptr pSession = ss1.currentSession();
ss1.close();
Thread::sleep(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
ss1.useSession(pSession);
ss1.connect(sa);
assert (ss1.sessionWasReused());
assert (ss1.currentSession() == pSession);
assertTrue (ss1.sessionWasReused());
assertTrue (ss1.currentSession() == pSession);
ss1.sendBytes(data.data(), (int) data.size());
n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assert (srv.currentConnections() == 1);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 2);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assertTrue (srv.currentConnections() == 1);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 2);
ss1.close();
Thread::sleep(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
Thread::sleep(15000); // wait for session to expire
pServerContext->flushSessionCache();
ss1.useSession(pSession);
ss1.connect(sa);
assert (!ss1.sessionWasReused());
assert (ss1.currentSession() != pSession);
assertTrue (!ss1.sessionWasReused());
assertTrue (ss1.currentSession() != pSession);
ss1.sendBytes(data.data(), (int) data.size());
n = ss1.receiveBytes(buffer, sizeof(buffer));
assert (n > 0);
assert (std::string(buffer, n) == data);
assert (srv.currentConnections() == 1);
assert (srv.queuedConnections() == 0);
assert (srv.totalConnections() == 3);
assertTrue (n > 0);
assertTrue (std::string(buffer, n) == data);
assertTrue (srv.currentConnections() == 1);
assertTrue (srv.queuedConnections() == 0);
assertTrue (srv.totalConnections() == 3);
ss1.close();
Thread::sleep(300);
assert (srv.currentConnections() == 0);
assertTrue (srv.currentConnections() == 0);
}