Merge branch 'poco-1.9.1' of https://github.com/pocoproject/poco.git into poco-1.9.1

.gitignore

@@ -41,6 +41,10 @@ coverage/
 config.build
 config.make
 
+# CLion #
+########
+.idea/
+
 # CMake #
 ########
 cmake_install.cmake
@@ -50,6 +54,7 @@ CMakeCache.txt
 CPackConfig.cmake
 CPackSourceConfig.cmake
 cmake_*
+cmake-build-*
 
 # Packages #
 ############

Net/testsuite/src/WebSocketTest.cpp

@@ -125,11 +125,11 @@ void WebSocketTest::testWebSocket()
 
 	std::string payload("x");
 	ws.sendFrame(payload.data(), (int) payload.size());
-	char buffer[1024];
+	char buffer[1024] = {};
 	int flags;
 	int n = ws.receiveFrame(buffer, sizeof(buffer), flags);
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), buffer, n) == 0);
 	assertTrue (flags == WebSocket::FRAME_TEXT);
 
 	for (int i = 2; i < 20; i++)
@@ -138,14 +138,16 @@ void WebSocketTest::testWebSocket()
 		ws.sendFrame(payload.data(), (int) payload.size());
 		n = ws.receiveFrame(buffer, sizeof(buffer), flags);
 		assertTrue (n == payload.size());
-		assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+		assertTrue (payload.compare(0, payload.size(), buffer, n) == 0);
 		assertTrue (flags == WebSocket::FRAME_TEXT);
 
 		ws.sendFrame(payload.data(), (int) payload.size());
 		Poco::Buffer<char> pocobuffer(0);
+		assertTrue(0 == pocobuffer.size());
 		n = ws.receiveFrame(pocobuffer, flags);
 		assertTrue (n == payload.size());
-		assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
+		assertTrue (n == pocobuffer.size());
+		assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), n) == 0);
 		assertTrue (flags == WebSocket::FRAME_TEXT);
 	}
 
@@ -155,14 +157,14 @@ void WebSocketTest::testWebSocket()
 		ws.sendFrame(payload.data(), (int) payload.size());
 		n = ws.receiveFrame(buffer, sizeof(buffer), flags);
 		assertTrue (n == payload.size());
-		assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+		assertTrue (payload.compare(0, payload.size(), buffer, n) == 0);
 		assertTrue (flags == WebSocket::FRAME_TEXT);
 
 		ws.sendFrame(payload.data(), (int) payload.size());
 		Poco::Buffer<char> pocobuffer(0);
 		n = ws.receiveFrame(pocobuffer, flags);
 		assertTrue (n == payload.size());
-		assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
+		assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), n) == 0);
 		assertTrue (flags == WebSocket::FRAME_TEXT);
 	}
 
@@ -170,15 +172,15 @@ void WebSocketTest::testWebSocket()
 	ws.sendFrame(payload.data(), (int) payload.size());
 	n = ws.receiveFrame(buffer, sizeof(buffer), flags);
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), buffer, 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);
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), buffer, n) == 0);
-	assertTrue (flags == WebSocket::FRAME_BINARY);	
+	assertTrue (flags == WebSocket::FRAME_BINARY);
 	
 	ws.shutdown();
 	n = ws.receiveFrame(buffer, sizeof(buffer), flags);
@@ -210,7 +212,7 @@ void WebSocketTest::testWebSocketLarge()
 	sstr << payload;
 	sstr.flush();
 
-	char buffer[msgSize + 1];
+	char buffer[msgSize + 1] = {};
 	int flags;
 	int n = 0;
 	do
@@ -219,7 +221,7 @@ void WebSocketTest::testWebSocketLarge()
 	} while (n > 0 && n < msgSize);
 
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), buffer, n) == 0);
 }
 
 
@@ -247,7 +249,7 @@ void WebSocketTest::testOneLargeFrame(int msgSize)
 
 	n = ws.receiveFrame(buffer.begin(), buffer.size(), flags);
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), buffer.begin(), 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), buffer.begin(), n) == 0);
 
 	ws.sendFrame(payload.data(), msgSize);
 
@@ -255,7 +257,7 @@ void WebSocketTest::testOneLargeFrame(int msgSize)
 
 	n = ws.receiveFrame(pocobuffer, flags);
 	assertTrue (n == payload.size());
-	assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), 0, n) == 0);
+	assertTrue (payload.compare(0, payload.size(), pocobuffer.begin(), n) == 0);
 }
 
 

NetSSL_OpenSSL/testsuite/Makefile

@@ -15,7 +15,8 @@ endif
 
 objects = NetSSLTestSuite Driver \
 	HTTPSClientSessionTest HTTPSClientTestSuite HTTPSServerTest HTTPSServerTestSuite \
-	HTTPSStreamFactoryTest HTTPSTestServer TCPServerTest TCPServerTestSuite
+	HTTPSStreamFactoryTest HTTPSTestServer TCPServerTest TCPServerTestSuite \
+	WebSocketTest WebSocketTestSuite
 
 target         = testrunner
 target_version = 1

NetSSL_OpenSSL/testsuite/src/NetSSLTestSuite.cpp

@@ -13,16 +13,17 @@
 #include "HTTPSClientTestSuite.h"
 #include "TCPServerTestSuite.h"
 #include "HTTPSServerTestSuite.h"
+#include "WebSocketTestSuite.h"
 
 
 CppUnit::Test* NetSSLTestSuite::suite()
 {
 	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("OpenSSLTestSuite");
 
-	
 	pSuite->addTest(HTTPSClientTestSuite::suite());
 	pSuite->addTest(TCPServerTestSuite::suite());
 	pSuite->addTest(HTTPSServerTestSuite::suite());
+	pSuite->addTest(WebSocketTestSuite::suite());
 
 	return pSuite;
 }

NetSSL_OpenSSL/testsuite/src/WebSocketTest.cpp

@@ -0,0 +1,233 @@
+//
+// WebSocketTest.cpp
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "WebSocketTest.h"
+#include "Poco/CppUnit/TestCaller.h"
+#include "Poco/CppUnit/TestSuite.h"
+#include "Poco/Net/WebSocket.h"
+#include "Poco/Net/SocketStream.h"
+#include "Poco/Net/HTTPSClientSession.h"
+#include "Poco/Net/HTTPServer.h"
+#include "Poco/Net/HTTPServerParams.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/SecureServerSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Thread.h"
+#include <iostream>
+
+using Poco::Net::HTTPSClientSession;
+using Poco::Net::HTTPRequest;
+using Poco::Net::HTTPResponse;
+using Poco::Net::HTTPServerRequest;
+using Poco::Net::HTTPServerResponse;
+using Poco::Net::SocketStream;
+using Poco::Net::WebSocket;
+using Poco::Net::WebSocketException;
+
+
+namespace
+{
+	class WebSocketRequestHandler: public Poco::Net::HTTPRequestHandler
+	{
+	public:
+		WebSocketRequestHandler(std::size_t bufSize = 1024): _bufSize(bufSize)
+		{
+		}
+
+		void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)
+		{
+			try
+			{
+				WebSocket ws(request, response);
+				std::unique_ptr<char[]> pBuffer(new char[_bufSize]);
+				int flags;
+				int n;
+				do
+				{
+					n = ws.receiveFrame(pBuffer.get(), static_cast<int>(_bufSize), flags);
+					if (n == 0)
+						break;
+					ws.sendFrame(pBuffer.get(), n, flags);
+				}
+				while ((flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE);
+			}
+			catch (WebSocketException& exc)
+			{
+				switch (exc.code())
+				{
+				case WebSocket::WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION:
+					response.set("Sec-WebSocket-Version", WebSocket::WEBSOCKET_VERSION);
+					// fallthrough
+				case WebSocket::WS_ERR_NO_HANDSHAKE:
+				case WebSocket::WS_ERR_HANDSHAKE_NO_VERSION:
+				case WebSocket::WS_ERR_HANDSHAKE_NO_KEY:
+					response.setStatusAndReason(HTTPResponse::HTTP_BAD_REQUEST);
+					response.setContentLength(0);
+					response.send();
+					break;
+				}
+			}
+		}
+
+	private:
+		std::size_t _bufSize;
+	};
+	
+	class WebSocketRequestHandlerFactory: public Poco::Net::HTTPRequestHandlerFactory
+	{
+	public:
+		WebSocketRequestHandlerFactory(std::size_t bufSize = 1024): _bufSize(bufSize)
+		{
+		}
+
+		Poco::Net::HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request)
+		{
+			return new WebSocketRequestHandler(_bufSize);
+		}
+
+	private:
+		std::size_t _bufSize;
+	};
+}
+
+
+WebSocketTest::WebSocketTest(const std::string& name): CppUnit::TestCase(name)
+{
+}
+
+
+WebSocketTest::~WebSocketTest()
+{
+}
+
+
+void WebSocketTest::testWebSocket()
+{
+	Poco::Net::SecureServerSocket ss(0);
+	Poco::Net::HTTPServer server(new WebSocketRequestHandlerFactory, ss, new Poco::Net::HTTPServerParams);
+	server.start();
+	
+	Poco::Thread::sleep(200);
+	
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
+	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
+	HTTPResponse response;
+	WebSocket ws(cs, request, response);
+
+	std::string payload("x");
+	ws.sendFrame(payload.data(), (int) payload.size());
+	char buffer[1024] = {};
+	int flags;
+	int n = ws.receiveFrame(buffer, sizeof(buffer), flags);
+	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);
+		assertTrue (n == payload.size());
+		assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+		assertTrue (flags == WebSocket::FRAME_TEXT);
+	}
+
+	for (int i = 125; i < 129; i++)
+	{
+		payload.assign(i, 'x');
+		ws.sendFrame(payload.data(), (int) payload.size());
+		n = ws.receiveFrame(buffer, sizeof(buffer), flags);
+		assertTrue (n == payload.size());
+		assertTrue (payload.compare(0, payload.size(), buffer, 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);
+	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);
+	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);
+	assertTrue (n == 2);
+	assertTrue ((flags & WebSocket::FRAME_OP_BITMASK) == WebSocket::FRAME_OP_CLOSE);
+	
+	server.stop();
+}
+
+
+void WebSocketTest::testWebSocketLarge()
+{
+	const int msgSize = 64000;
+
+	Poco::Net::SecureServerSocket ss(0);
+	Poco::Net::HTTPServer server(new WebSocketRequestHandlerFactory(msgSize), ss, new Poco::Net::HTTPServerParams);
+	server.start();
+
+	Poco::Thread::sleep(200);
+	
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
+	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
+	HTTPResponse response;
+	WebSocket ws(cs, request, response);
+	ws.setSendBufferSize(msgSize);
+	ws.setReceiveBufferSize(msgSize);
+	std::string payload(msgSize, 'x');
+	SocketStream sstr(ws);
+	sstr << payload;
+	sstr.flush();
+
+	char buffer[msgSize + 1] = {};
+	int flags;
+	int n = 0;
+	do
+	{
+		n += ws.receiveFrame(buffer + n, sizeof(buffer) - n, flags);
+	} while (n > 0 && n < msgSize);
+
+	assertTrue (n == payload.size());
+	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+
+	server.stop();
+}
+
+
+void WebSocketTest::setUp()
+{
+}
+
+
+void WebSocketTest::tearDown()
+{
+}
+
+
+CppUnit::Test* WebSocketTest::suite()
+{
+	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("WebSocketTest");
+
+	CppUnit_addTest(pSuite, WebSocketTest, testWebSocket);
+	CppUnit_addTest(pSuite, WebSocketTest, testWebSocketLarge);
+
+	return pSuite;
+}

NetSSL_OpenSSL/testsuite/src/WebSocketTest.h

@@ -0,0 +1,39 @@
+//
+// WebSocketTest.h
+//
+// Definition of the WebSocketTest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef WebSocketTest_INCLUDED
+#define WebSocketTest_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/CppUnit/TestCase.h"
+
+
+class WebSocketTest: public CppUnit::TestCase
+{
+public:
+	WebSocketTest(const std::string& name);
+	~WebSocketTest();
+
+	void testWebSocket();
+	void testWebSocketLarge();
+
+	void setUp();
+	void tearDown();
+
+	static CppUnit::Test* suite();
+
+private:
+};
+
+
+#endif // WebSocketTest_INCLUDED

NetSSL_OpenSSL/testsuite/src/WebSocketTestSuite.cpp

@@ -0,0 +1,22 @@
+//
+// WebSocketTestSuite.cpp
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "WebSocketTestSuite.h"
+#include "WebSocketTest.h"
+
+
+CppUnit::Test* WebSocketTestSuite::suite()
+{
+	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("WebSocketTestSuite");
+
+	pSuite->addTest(WebSocketTest::suite());
+
+	return pSuite;
+}

NetSSL_OpenSSL/testsuite/src/WebSocketTestSuite.h

@@ -0,0 +1,27 @@
+//
+// WebSocketTestSuite.h
+//
+// Definition of the WebSocketTestSuite class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef WebSocketTestSuite_INCLUDED
+#define WebSocketTestSuite_INCLUDED
+
+
+#include "CppUnit/TestSuite.h"
+
+
+class WebSocketTestSuite
+{
+public:
+	static CppUnit::Test* suite();
+};
+
+
+#endif // WebSocketTestSuite_INCLUDED

NetSSL_Win/testsuite/src/WebSocketTest.cpp

@@ -0,0 +1,231 @@
+//
+// WebSocketTest.cpp
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "WebSocketTest.h"
+#include "Poco/CppUnit/TestCaller.h"
+#include "Poco/CppUnit/TestSuite.h"
+#include "Poco/Net/WebSocket.h"
+#include "Poco/Net/SocketStream.h"
+#include "Poco/Net/HTTPSClientSession.h"
+#include "Poco/Net/HTTPServer.h"
+#include "Poco/Net/HTTPServerParams.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/SecureServerSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Thread.h"
+
+
+using Poco::Net::HTTPSClientSession;
+using Poco::Net::HTTPRequest;
+using Poco::Net::HTTPResponse;
+using Poco::Net::HTTPServerRequest;
+using Poco::Net::HTTPServerResponse;
+using Poco::Net::SocketStream;
+using Poco::Net::WebSocket;
+using Poco::Net::WebSocketException;
+
+
+namespace
+{
+	class WebSocketRequestHandler: public Poco::Net::HTTPRequestHandler
+	{
+	public:
+		WebSocketRequestHandler(std::size_t bufSize = 1024): _bufSize(bufSize)
+		{
+		}
+
+		void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)
+		{
+			try
+			{
+				WebSocket ws(request, response);
+				std::unique_ptr<char[]> pBuffer(new char[_bufSize]);
+				int flags;
+				int n;
+				do
+				{
+					n = ws.receiveFrame(pBuffer.get(), static_cast<int>(_bufSize), flags);
+					if (n == 0)
+						break;
+					ws.sendFrame(pBuffer.get(), n, flags);
+				}
+				while ((flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE);
+			}
+			catch (WebSocketException& exc)
+			{
+				switch (exc.code())
+				{
+				case WebSocket::WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION:
+					response.set("Sec-WebSocket-Version", WebSocket::WEBSOCKET_VERSION);
+					// fallthrough
+				case WebSocket::WS_ERR_NO_HANDSHAKE:
+				case WebSocket::WS_ERR_HANDSHAKE_NO_VERSION:
+				case WebSocket::WS_ERR_HANDSHAKE_NO_KEY:
+					response.setStatusAndReason(HTTPResponse::HTTP_BAD_REQUEST);
+					response.setContentLength(0);
+					response.send();
+					break;
+				}
+			}
+		}
+
+	private:
+		std::size_t _bufSize;
+	};
+	
+	class WebSocketRequestHandlerFactory: public Poco::Net::HTTPRequestHandlerFactory
+	{
+	public:
+		WebSocketRequestHandlerFactory(std::size_t bufSize = 1024): _bufSize(bufSize)
+		{
+		}
+
+		Poco::Net::HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request)
+		{
+			return new WebSocketRequestHandler(_bufSize);
+		}
+
+	private:
+		std::size_t _bufSize;
+	};
+}
+
+
+WebSocketTest::WebSocketTest(const std::string& name): CppUnit::TestCase(name)
+{
+}
+
+
+WebSocketTest::~WebSocketTest()
+{
+}
+
+
+void WebSocketTest::testWebSocket()
+{
+	Poco::Net::SecureServerSocket ss(0);
+	Poco::Net::HTTPServer server(new WebSocketRequestHandlerFactory, ss, new Poco::Net::HTTPServerParams);
+	server.start();
+	
+	Poco::Thread::sleep(200);
+	
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
+	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
+	HTTPResponse response;
+	WebSocket ws(cs, request, response);
+
+	std::string payload("x");
+	ws.sendFrame(payload.data(), (int) payload.size());
+	char buffer[1024] = {};
+	int flags;
+	int n = ws.receiveFrame(buffer, sizeof(buffer), flags);
+	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);
+		assertTrue (n == payload.size());
+		assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+		assertTrue (flags == WebSocket::FRAME_TEXT);
+	}
+
+	for (int i = 125; i < 129; i++)
+	{
+		payload.assign(i, 'x');
+		ws.sendFrame(payload.data(), (int) payload.size());
+		n = ws.receiveFrame(buffer, sizeof(buffer), flags);
+		assertTrue (n == payload.size());
+		assertTrue (payload.compare(0, payload.size(), buffer, 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);
+	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);
+	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);
+	assertTrue (n == 2);
+	assertTrue ((flags & WebSocket::FRAME_OP_BITMASK) == WebSocket::FRAME_OP_CLOSE);
+	
+	server.stop();
+}
+
+
+void WebSocketTest::testWebSocketLarge()
+{
+	const int msgSize = 64000;
+
+	Poco::Net::SecureServerSocket ss(0);
+	Poco::Net::HTTPServer server(new WebSocketRequestHandlerFactory(msgSize), ss, new Poco::Net::HTTPServerParams);
+	server.start();
+	
+	Poco::Thread::sleep(200);
+	
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
+	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
+	HTTPResponse response;
+	WebSocket ws(cs, request, response);
+	ws.setSendBufferSize(msgSize);
+	ws.setReceiveBufferSize(msgSize);
+	std::string payload(msgSize, 'x');
+	SocketStream sstr(ws);
+	sstr << payload;
+	sstr.flush();
+
+	char buffer[msgSize + 1] = {};
+	int flags;
+	int n = 0;
+	do
+	{
+		n += ws.receiveFrame(buffer + n, sizeof(buffer) - n, flags);
+	} while (n > 0 && n < msgSize);
+
+	assertTrue (n == payload.size());
+	assertTrue (payload.compare(0, payload.size(), buffer, 0, n) == 0);
+}
+
+
+void WebSocketTest::setUp()
+{
+}
+
+
+void WebSocketTest::tearDown()
+{
+}
+
+
+CppUnit::Test* WebSocketTest::suite()
+{
+	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("WebSocketTest");
+
+	CppUnit_addTest(pSuite, WebSocketTest, testWebSocket);
+	CppUnit_addTest(pSuite, WebSocketTest, testWebSocketLarge);
+
+	return pSuite;
+}

NetSSL_Win/testsuite/src/WebSocketTest.h

@@ -0,0 +1,39 @@
+//
+// WebSocketTest.h
+//
+// Definition of the WebSocketTest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef WebSocketTest_INCLUDED
+#define WebSocketTest_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/CppUnit/TestCase.h"
+
+
+class WebSocketTest: public CppUnit::TestCase
+{
+public:
+	WebSocketTest(const std::string& name);
+	~WebSocketTest();
+
+	void testWebSocket();
+	void testWebSocketLarge();
+
+	void setUp();
+	void tearDown();
+
+	static CppUnit::Test* suite();
+
+private:
+};
+
+
+#endif // WebSocketTest_INCLUDED