Squashed 'src/websocketpp/' content from commit 875d420

git-subtree-dir: src/websocketpp
git-subtree-split: 875d420952d2c47d38de15952a401f00773cdffc

test/connection/SConscript

@@ -0,0 +1,25 @@
+## connection unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
+
+objs = env.Object('connection_boost.o', ["connection.cpp"], LIBS = BOOST_LIBS)
+objs = env.Object('connection_tu2_boost.o', ["connection_tu2.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_connection_boost', ["connection_boost.o","connection_tu2_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('connection_stl.o', ["connection.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('connection_tu2_stl.o', ["connection_tu2.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_connection_stl', ["connection_stl.o","connection_tu2_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/connection/connection.cpp

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE connection
+#include <boost/test/unit_test.hpp>
+
+#include "connection_tu2.hpp"
+
+// NOTE: these tests currently test against hardcoded output values. I am not
+// sure how problematic this will be. If issues arise like order of headers the
+// output should be parsed by http::response and have values checked directly
+
+BOOST_AUTO_TEST_CASE( basic_http_request ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 426 Upgrade Required\r\nServer: " +
+                         std::string(websocketpp::user_agent)+"\r\n\r\n";
+
+    std::string o2 = run_server_test(input);
+
+    BOOST_CHECK(o2 == output);
+}
+
+struct connection_extension {
+    connection_extension() : extension_value(5) {}
+
+    int extension_method() {
+        return extension_value;
+    }
+
+    bool is_server() const {
+        return false;
+    }
+
+    int extension_value;
+};
+
+struct stub_config : public websocketpp::config::core {
+    typedef core::concurrency_type concurrency_type;
+
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+
+    typedef core::rng_type rng_type;
+
+    typedef core::transport_type transport_type;
+
+    typedef core::endpoint_base endpoint_base;
+    typedef connection_extension connection_base;
+};
+
+struct connection_setup {
+    connection_setup(bool p_is_server) : c(p_is_server, "", alog, elog, rng) {}
+
+    websocketpp::lib::error_code ec;
+    stub_config::alog_type alog;
+    stub_config::elog_type elog;
+    stub_config::rng_type rng;
+    websocketpp::connection<stub_config> c;
+};
+
+/*void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    s->send(hdl, msg->get_payload(), msg->get_opcode());
+}*/
+
+void validate_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    s->send(hdl, msg->get_payload(), msg->get_opcode());
+}
+
+bool validate_set_ua(server* s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+    con->replace_header("Server","foo");
+    return true;
+}
+
+void http_func(server* s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+
+    std::string res = con->get_resource();
+
+    con->set_body(res);
+    con->set_status(websocketpp::http::status_code::ok);
+}
+
+BOOST_AUTO_TEST_CASE( connection_extensions ) {
+    connection_setup env(true);
+
+    BOOST_CHECK( env.c.extension_value == 5 );
+    BOOST_CHECK( env.c.extension_method() == 5 );
+
+    BOOST_CHECK( env.c.is_server() == true );
+}
+
+BOOST_AUTO_TEST_CASE( basic_websocket_request ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: ";
+    output+=websocketpp::user_agent;
+    output+="\r\nUpgrade: websocket\r\n\r\n";
+
+    server s;
+    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
+
+    BOOST_CHECK(run_server_test(s,input) == output);
+}
+
+BOOST_AUTO_TEST_CASE( http_request ) {
+    std::string input = "GET /foo/bar HTTP/1.1\r\nHost: www.example.com\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 200 OK\r\nContent-Length: 8\r\nServer: ";
+    output+=websocketpp::user_agent;
+    output+="\r\n\r\n/foo/bar";
+
+    server s;
+    s.set_http_handler(bind(&http_func,&s,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( request_no_server_header ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nUpgrade: websocket\r\n\r\n";
+
+    server s;
+    s.set_user_agent("");
+    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( request_no_server_header_override ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
+
+    server s;
+    s.set_user_agent("");
+    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
+    s.set_validate_handler(bind(&validate_set_ua,&s,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( basic_client_websocket ) {
+    std::string uri = "ws://localhost";
+
+    //std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string ref = "GET / HTTP/1.1\r\nConnection: Upgrade\r\nFoo: Bar\r\nHost: localhost\r\nSec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\nSec-WebSocket-Version: 13\r\nUpgrade: websocket\r\nUser-Agent: foo\r\n\r\n";
+
+    std::stringstream output;
+
+    client e;
+    e.set_access_channels(websocketpp::log::alevel::none);
+    e.set_error_channels(websocketpp::log::elevel::none);
+    e.set_user_agent("foo");
+    e.register_ostream(&output);
+
+    client::connection_ptr con;
+    websocketpp::lib::error_code ec;
+    con = e.get_connection(uri, ec);
+    con->append_header("Foo","Bar");
+    e.connect(con);
+
+    BOOST_CHECK_EQUAL(ref, output.str());
+}
+
+BOOST_AUTO_TEST_CASE( set_max_message_size ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+    
+    // After the handshake, add a single frame with a message that is too long.
+    char frame0[10] = {char(0x82), char(0x83), 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01};
+    input.append(frame0, 10);
+    
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
+
+    // After the handshake, add a single frame with a close message with message too big
+    // error code.
+    char frame1[4] = {char(0x88), 0x19, 0x03, char(0xf1)};
+    output.append(frame1, 4);
+    output.append("A message was too large");
+
+    server s;
+    s.set_user_agent("");
+    s.set_validate_handler(bind(&validate_set_ua,&s,::_1));
+    s.set_max_message_size(2);
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+// TODO: set max message size in client endpoint test case
+// TODO: set max message size mid connection test case
+// TODO: [maybe] set max message size in open handler
+
+/*
+
+BOOST_AUTO_TEST_CASE( user_reject_origin ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example2.com\r\n\r\n";
+    std::string output = "HTTP/1.1 403 Forbidden\r\nServer: "+websocketpp::USER_AGENT+"\r\n\r\n";
+
+    BOOST_CHECK(run_server_test(input) == output);
+}
+
+BOOST_AUTO_TEST_CASE( basic_text_message ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+
+    unsigned char frames[8] = {0x82,0x82,0xFF,0xFF,0xFF,0xFF,0xD5,0xD5};
+    input.append(reinterpret_cast<char*>(frames),8);
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: "+websocketpp::USER_AGENT+"\r\nUpgrade: websocket\r\n\r\n**";
+
+    BOOST_CHECK( run_server_test(input) == output);
+}
+*/

test/connection/connection_tu2.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "connection_tu2.hpp"
+
+void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    s->send(hdl, msg->get_payload(), msg->get_opcode());
+}
+
+std::string run_server_test(std::string input) {
+    server test_server;
+    return run_server_test(test_server,input);
+}
+
+std::string run_server_test(server & s, std::string input) {
+    server::connection_ptr con;
+    std::stringstream output;
+
+    s.clear_access_channels(websocketpp::log::alevel::all);
+    s.clear_error_channels(websocketpp::log::elevel::all);
+
+    s.register_ostream(&output);
+
+    con = s.get_connection();
+    con->start();
+
+    std::stringstream channel;
+
+    channel << input;
+    channel >> *con;
+
+    return output.str();
+}

test/connection/connection_tu2.hpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <iostream>
+#include <sstream>
+
+// Test Environment:
+// server, no TLS, no locks, iostream based transport
+#include <websocketpp/config/core.hpp>
+#include <websocketpp/server.hpp>
+#include <websocketpp/client.hpp>
+
+typedef websocketpp::server<websocketpp::config::core> server;
+/// NOTE: the "server" config is being used for the client here because we don't
+/// want to pull in the real RNG. A better way to do this might be a custom
+/// client config with the RNG explicitly stubbed out.
+typedef websocketpp::client<websocketpp::config::core> client;
+typedef websocketpp::config::core::message_type::ptr message_ptr;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg);
+std::string run_server_test(std::string input);
+std::string run_server_test(server & s, std::string input);

test/endpoint/SConscript

@@ -0,0 +1,24 @@
+## endpoint unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + [tls_libs]
+
+objs = env.Object('endpoint_boost.o', ["endpoint.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_endpoint_boost', ["endpoint_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   objs += env_cpp11.Object('endpoint_stl.o', ["endpoint.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_endpoint_stl', ["endpoint_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/endpoint/endpoint.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE endpoint
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <sstream>
+
+#include <websocketpp/config/asio.hpp>
+#include <websocketpp/server.hpp>
+
+BOOST_AUTO_TEST_CASE( construct_server_iostream ) {
+    websocketpp::server<websocketpp::config::core> s;
+}
+
+BOOST_AUTO_TEST_CASE( construct_server_asio_plain ) {
+    websocketpp::server<websocketpp::config::asio> s;
+}
+
+BOOST_AUTO_TEST_CASE( construct_server_asio_tls ) {
+    websocketpp::server<websocketpp::config::asio_tls> s;
+}
+
+BOOST_AUTO_TEST_CASE( initialize_server_asio ) {
+    websocketpp::server<websocketpp::config::asio> s;
+    s.init_asio();
+}
+
+BOOST_AUTO_TEST_CASE( initialize_server_asio_external ) {
+    websocketpp::server<websocketpp::config::asio> s;
+    boost::asio::io_service ios;
+    s.init_asio(&ios);
+}
+
+struct endpoint_extension {
+    endpoint_extension() : extension_value(5) {}
+
+    int extension_method() {
+        return extension_value;
+    }
+
+    bool is_server() const {
+        return false;
+    }
+
+    int extension_value;
+};
+
+struct stub_config : public websocketpp::config::core {
+    typedef core::concurrency_type concurrency_type;
+
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+
+    typedef core::rng_type rng_type;
+
+    typedef core::transport_type transport_type;
+
+    typedef endpoint_extension endpoint_base;
+};
+
+BOOST_AUTO_TEST_CASE( endpoint_extensions ) {
+    websocketpp::server<stub_config> s;
+
+    BOOST_CHECK( s.extension_value == 5 );
+    BOOST_CHECK( s.extension_method() == 5 );
+
+    BOOST_CHECK( s.is_server() == true );
+}

test/extension/SConscript

@@ -0,0 +1,27 @@
+## http unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + ['z']
+
+objs = env.Object('extension_boost.o', ["extension.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('permessage_deflate_boost.o', ["permessage_deflate.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_extension_boost', ["extension_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_permessage_deflate_boost', ["permessage_deflate_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
+   objs += env_cpp11.Object('extension_stl.o', ["extension.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('permessage_deflate_stl.o', ["permessage_deflate.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_extension_stl', ["extension_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_permessage_deflate_stl', ["permessage_deflate_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/extension/extension.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE extension
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+#include <websocketpp/extensions/extension.hpp>
+
+BOOST_AUTO_TEST_CASE( blank ) {
+    BOOST_CHECK( true );
+}

test/extension/permessage_deflate.cpp

@@ -0,0 +1,543 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE permessage_deflate
+#include <boost/test/unit_test.hpp>
+
+#include <websocketpp/error.hpp>
+
+#include <websocketpp/extensions/extension.hpp>
+#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
+#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
+
+#include <string>
+
+#include <websocketpp/utilities.hpp>
+#include <iostream>
+
+class config {};
+
+typedef websocketpp::extensions::permessage_deflate::enabled<config> enabled_type;
+typedef websocketpp::extensions::permessage_deflate::disabled<config> disabled_type;
+
+struct ext_vars {
+    enabled_type exts;
+    enabled_type extc;
+    websocketpp::lib::error_code ec;
+    websocketpp::err_str_pair esp;
+    websocketpp::http::attribute_list attr;
+};
+namespace pmde = websocketpp::extensions::permessage_deflate::error;
+namespace pmd_mode = websocketpp::extensions::permessage_deflate::mode;
+
+// Ensure the disabled extension behaves appropriately disabled
+
+BOOST_AUTO_TEST_CASE( disabled_is_disabled ) {
+    disabled_type exts;
+    BOOST_CHECK( !exts.is_implemented() );
+}
+
+BOOST_AUTO_TEST_CASE( disabled_is_off ) {
+    disabled_type exts;
+    BOOST_CHECK( !exts.is_enabled() );
+}
+
+// Ensure the enabled version actually works
+
+BOOST_AUTO_TEST_CASE( enabled_is_enabled ) {
+    ext_vars v;
+    BOOST_CHECK( v.exts.is_implemented() );
+    BOOST_CHECK( v.extc.is_implemented() );
+}
+
+
+BOOST_AUTO_TEST_CASE( enabled_starts_disabled ) {
+    ext_vars v;
+    BOOST_CHECK( !v.exts.is_enabled() );
+    BOOST_CHECK( !v.extc.is_enabled() );
+}
+
+BOOST_AUTO_TEST_CASE( negotiation_empty_attr ) {
+    ext_vars v;
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+}
+
+BOOST_AUTO_TEST_CASE( negotiation_invalid_attr ) {
+    ext_vars v;
+    v.attr["foo"] = "bar";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( !v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attributes) );
+    BOOST_CHECK_EQUAL( v.esp.second, "");
+}
+
+// Negotiate s2c_no_context_takeover
+BOOST_AUTO_TEST_CASE( negotiate_s2c_no_context_takeover_invalid ) {
+    ext_vars v;
+    v.attr["s2c_no_context_takeover"] = "foo";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( !v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
+    BOOST_CHECK_EQUAL( v.esp.second, "");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_no_context_takeover ) {
+    ext_vars v;
+    v.attr["s2c_no_context_takeover"] = "";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_no_context_takeover_server_initiated ) {
+    ext_vars v;
+
+    v.exts.enable_s2c_no_context_takeover();
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover");
+}
+
+// Negotiate c2s_no_context_takeover
+BOOST_AUTO_TEST_CASE( negotiate_c2s_no_context_takeover_invalid ) {
+    ext_vars v;
+    v.attr["c2s_no_context_takeover"] = "foo";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( !v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
+    BOOST_CHECK_EQUAL( v.esp.second, "");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_no_context_takeover ) {
+    ext_vars v;
+    v.attr["c2s_no_context_takeover"] = "";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_no_context_takeover");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_no_context_takeover_server_initiated ) {
+    ext_vars v;
+
+    v.exts.enable_c2s_no_context_takeover();
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_no_context_takeover");
+}
+
+
+// Negotiate s2c_max_window_bits
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_invalid ) {
+    ext_vars v;
+
+    std::vector<std::string> values;
+    values.push_back("");
+    values.push_back("foo");
+    values.push_back("7");
+    values.push_back("16");
+
+    std::vector<std::string>::const_iterator it;
+    for (it = values.begin(); it != values.end(); ++it) {
+        v.attr["s2c_max_window_bits"] = *it;
+
+        v.esp = v.exts.negotiate(v.attr);
+        BOOST_CHECK( !v.exts.is_enabled() );
+        BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
+        BOOST_CHECK_EQUAL( v.esp.second, "");
+    }
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_valid ) {
+    ext_vars v;
+    v.attr["s2c_max_window_bits"] = "8";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_max_window_bits=8");
+
+    v.attr["s2c_max_window_bits"] = "15";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+}
+
+BOOST_AUTO_TEST_CASE( invalid_set_s2c_max_window_bits ) {
+    ext_vars v;
+
+    v.ec = v.exts.set_s2c_max_window_bits(7,pmd_mode::decline);
+    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
+
+    v.ec = v.exts.set_s2c_max_window_bits(16,pmd_mode::decline);
+    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_decline ) {
+    ext_vars v;
+    v.attr["s2c_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_s2c_max_window_bits(15,pmd_mode::decline);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_accept ) {
+    ext_vars v;
+    v.attr["s2c_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_s2c_max_window_bits(15,pmd_mode::accept);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_max_window_bits=8");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_largest ) {
+    ext_vars v;
+    v.attr["s2c_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_s2c_max_window_bits(15,pmd_mode::largest);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_max_window_bits=8");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_s2c_max_window_bits_smallest ) {
+    ext_vars v;
+    v.attr["s2c_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_s2c_max_window_bits(15,pmd_mode::smallest);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_max_window_bits=8");
+}
+
+// Negotiate s2c_max_window_bits
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_invalid ) {
+    ext_vars v;
+
+    std::vector<std::string> values;
+    values.push_back("foo");
+    values.push_back("7");
+    values.push_back("16");
+
+    std::vector<std::string>::const_iterator it;
+    for (it = values.begin(); it != values.end(); ++it) {
+        v.attr["c2s_max_window_bits"] = *it;
+
+        v.esp = v.exts.negotiate(v.attr);
+        BOOST_CHECK( !v.exts.is_enabled() );
+        BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
+        BOOST_CHECK_EQUAL( v.esp.second, "");
+    }
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_valid ) {
+    ext_vars v;
+
+    v.attr["c2s_max_window_bits"] = "";
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+
+    v.attr["c2s_max_window_bits"] = "8";
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_max_window_bits=8");
+
+    v.attr["c2s_max_window_bits"] = "15";
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+}
+
+BOOST_AUTO_TEST_CASE( invalid_set_c2s_max_window_bits ) {
+    ext_vars v;
+
+    v.ec = v.exts.set_c2s_max_window_bits(7,pmd_mode::decline);
+    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
+
+    v.ec = v.exts.set_c2s_max_window_bits(16,pmd_mode::decline);
+    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_decline ) {
+    ext_vars v;
+    v.attr["c2s_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_c2s_max_window_bits(8,pmd_mode::decline);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_accept ) {
+    ext_vars v;
+    v.attr["c2s_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_c2s_max_window_bits(15,pmd_mode::accept);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_max_window_bits=8");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_largest ) {
+    ext_vars v;
+    v.attr["c2s_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_c2s_max_window_bits(15,pmd_mode::largest);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_max_window_bits=8");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_c2s_max_window_bits_smallest ) {
+    ext_vars v;
+    v.attr["c2s_max_window_bits"] = "8";
+
+    v.ec = v.exts.set_c2s_max_window_bits(15,pmd_mode::smallest);
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_max_window_bits=8");
+}
+
+
+// Combinations with 2
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated1 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["c2s_no_context_takeover"] = "";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; c2s_no_context_takeover");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated2 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; s2c_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated3 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated4 ) {
+    ext_vars v;
+
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_no_context_takeover; s2c_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated5 ) {
+    ext_vars v;
+
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_no_context_takeover; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated6 ) {
+    ext_vars v;
+
+    v.attr["s2c_max_window_bits"] = "10";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_max_window_bits=10; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated1 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; c2s_no_context_takeover; s2c_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated2 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; c2s_no_context_takeover; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated3 ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; s2c_max_window_bits=10; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated4 ) {
+    ext_vars v;
+
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; c2s_no_context_takeover; s2c_max_window_bits=10; c2s_max_window_bits=10");
+}
+
+BOOST_AUTO_TEST_CASE( negotiate_four_client_initiated ) {
+    ext_vars v;
+
+    v.attr["s2c_no_context_takeover"] = "";
+    v.attr["c2s_no_context_takeover"] = "";
+    v.attr["s2c_max_window_bits"] = "10";
+    v.attr["c2s_max_window_bits"] = "10";
+
+    v.esp = v.exts.negotiate(v.attr);
+    BOOST_CHECK( v.exts.is_enabled() );
+    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
+    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; s2c_no_context_takeover; c2s_no_context_takeover; s2c_max_window_bits=10; c2s_max_window_bits=10");
+}
+
+// Compression
+/*
+BOOST_AUTO_TEST_CASE( compress_data ) {
+    ext_vars v;
+
+    std::string in = "Hello";
+    std::string out;
+    std::string in2;
+    std::string out2;
+
+    v.exts.init();
+
+    v.ec = v.exts.compress(in,out);
+
+    std::cout << "in : " << websocketpp::utility::to_hex(in) << std::endl;
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    std::cout << "out: " << websocketpp::utility::to_hex(out) << std::endl;
+
+    in2 = out;
+
+    v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(in2.data()),in2.size(),out2);
+
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    std::cout << "out: " << websocketpp::utility::to_hex(out2) << std::endl;
+    BOOST_CHECK_EQUAL( out, out2 );
+}
+
+BOOST_AUTO_TEST_CASE( decompress_data ) {
+    ext_vars v;
+
+    uint8_t in[12] = {0xf2, 0x48, 0xcd, 0xc9, 0xc9, 0x07, 0x00, 0x00, 0x00, 0xff, 0xff};
+    std::string out;
+
+    v.exts.init();
+
+    v.ec = v.exts.decompress(in,12,out);
+
+    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
+    std::cout << "out: " << websocketpp::utility::to_hex(out) << std::endl;
+    BOOST_CHECK( false );
+}
+*/

test/http/SConscript

@@ -0,0 +1,23 @@
+## http unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework'],env) + [platform_libs]
+
+objs = env.Object('parser_boost.o', ["parser.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_http_boost', ["parser_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('parser_stl.o', ["parser.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_http_stl', ["parser_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/http/parser.cpp

@@ -0,0 +1,968 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE http_parser
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+
+BOOST_AUTO_TEST_CASE( is_token_char ) {
+    // Valid characters
+
+    // misc
+    BOOST_CHECK( websocketpp::http::is_token_char('!') );
+    BOOST_CHECK( websocketpp::http::is_token_char('#') );
+    BOOST_CHECK( websocketpp::http::is_token_char('$') );
+    BOOST_CHECK( websocketpp::http::is_token_char('%') );
+    BOOST_CHECK( websocketpp::http::is_token_char('&') );
+    BOOST_CHECK( websocketpp::http::is_token_char('\'') );
+    BOOST_CHECK( websocketpp::http::is_token_char('*') );
+    BOOST_CHECK( websocketpp::http::is_token_char('+') );
+    BOOST_CHECK( websocketpp::http::is_token_char('-') );
+    BOOST_CHECK( websocketpp::http::is_token_char('.') );
+    BOOST_CHECK( websocketpp::http::is_token_char('^') );
+    BOOST_CHECK( websocketpp::http::is_token_char('_') );
+    BOOST_CHECK( websocketpp::http::is_token_char('`') );
+    BOOST_CHECK( websocketpp::http::is_token_char('~') );
+
+    // numbers
+    for (int i = 0x30; i < 0x3a; i++) {
+        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
+    }
+
+    // upper
+    for (int i = 0x41; i < 0x5b; i++) {
+        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
+    }
+
+    // lower
+    for (int i = 0x61; i < 0x7b; i++) {
+        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
+    }
+
+    // invalid characters
+
+    // lower unprintable
+    for (int i = 0; i < 33; i++) {
+        BOOST_CHECK( !websocketpp::http::is_token_char((unsigned char)(i)) );
+    }
+
+    // misc
+    BOOST_CHECK( !websocketpp::http::is_token_char('(') );
+    BOOST_CHECK( !websocketpp::http::is_token_char(')') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('<') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('>') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('@') );
+    BOOST_CHECK( !websocketpp::http::is_token_char(',') );
+    BOOST_CHECK( !websocketpp::http::is_token_char(';') );
+    BOOST_CHECK( !websocketpp::http::is_token_char(':') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('\\') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('"') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('/') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('[') );
+    BOOST_CHECK( !websocketpp::http::is_token_char(']') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('?') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('=') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('{') );
+    BOOST_CHECK( !websocketpp::http::is_token_char('}') );
+
+    // upper unprintable and out of ascii range
+    for (int i = 127; i < 256; i++) {
+        BOOST_CHECK( !websocketpp::http::is_token_char((unsigned char)(i)) );
+    }
+
+    // is not
+    BOOST_CHECK( !websocketpp::http::is_not_token_char('!') );
+    BOOST_CHECK( websocketpp::http::is_not_token_char('(') );
+}
+
+BOOST_AUTO_TEST_CASE( extract_token ) {
+    std::string d1 = "foo";
+    std::string d2 = " foo ";
+
+    std::pair<std::string,std::string::const_iterator> ret;
+
+    ret = websocketpp::http::parser::extract_token(d1.begin(),d1.end());
+    BOOST_CHECK( ret.first == "foo" );
+    BOOST_CHECK( ret.second == d1.begin()+3 );
+
+    ret = websocketpp::http::parser::extract_token(d2.begin(),d2.end());
+    BOOST_CHECK( ret.first == "" );
+    BOOST_CHECK( ret.second == d2.begin()+0 );
+
+    ret = websocketpp::http::parser::extract_token(d2.begin()+1,d2.end());
+    BOOST_CHECK( ret.first == "foo" );
+    BOOST_CHECK( ret.second == d2.begin()+4 );
+}
+
+BOOST_AUTO_TEST_CASE( extract_quoted_string ) {
+    std::string d1 = "\"foo\"";
+    std::string d2 = "\"foo\\\"bar\\\"baz\"";
+    std::string d3 = "\"foo\"     ";
+    std::string d4 = "";
+    std::string d5 = "foo";
+
+    std::pair<std::string,std::string::const_iterator> ret;
+
+    using websocketpp::http::parser::extract_quoted_string;
+
+    ret = extract_quoted_string(d1.begin(),d1.end());
+    BOOST_CHECK( ret.first == "foo" );
+    BOOST_CHECK( ret.second == d1.end() );
+
+    ret = extract_quoted_string(d2.begin(),d2.end());
+    BOOST_CHECK( ret.first == "foo\"bar\"baz" );
+    BOOST_CHECK( ret.second == d2.end() );
+
+    ret = extract_quoted_string(d3.begin(),d3.end());
+    BOOST_CHECK( ret.first == "foo" );
+    BOOST_CHECK( ret.second == d3.begin()+5 );
+
+    ret = extract_quoted_string(d4.begin(),d4.end());
+    BOOST_CHECK( ret.first == "" );
+    BOOST_CHECK( ret.second == d4.begin() );
+
+    ret = extract_quoted_string(d5.begin(),d5.end());
+    BOOST_CHECK( ret.first == "" );
+    BOOST_CHECK( ret.second == d5.begin() );
+}
+
+BOOST_AUTO_TEST_CASE( extract_all_lws ) {
+    std::string d1 = " foo     bar";
+    d1.append(1,char(9));
+    d1.append("baz\r\n d\r\n  \r\n  e\r\nf");
+
+    std::string::const_iterator ret;
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin(),d1.end());
+    BOOST_CHECK( ret == d1.begin()+1 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+1,d1.end());
+    BOOST_CHECK( ret == d1.begin()+1 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+4,d1.end());
+    BOOST_CHECK( ret == d1.begin()+9 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+12,d1.end());
+    BOOST_CHECK( ret == d1.begin()+13 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+16,d1.end());
+    BOOST_CHECK( ret == d1.begin()+19 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+20,d1.end());
+    BOOST_CHECK( ret == d1.begin()+28 );
+
+    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+29,d1.end());
+    BOOST_CHECK( ret == d1.begin()+29 );
+}
+
+BOOST_AUTO_TEST_CASE( extract_attributes_blank ) {
+    std::string s = "";
+
+    websocketpp::http::attribute_list a;
+    std::string::const_iterator it;
+
+    it = websocketpp::http::parser::extract_attributes(s.begin(),s.end(),a);
+    BOOST_CHECK( it == s.begin() );
+    BOOST_CHECK_EQUAL( a.size(), 0 );
+}
+
+BOOST_AUTO_TEST_CASE( extract_attributes_simple ) {
+    std::string s = "foo";
+
+    websocketpp::http::attribute_list a;
+    std::string::const_iterator it;
+
+    it = websocketpp::http::parser::extract_attributes(s.begin(),s.end(),a);
+    BOOST_CHECK( it == s.end() );
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("foo") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("foo")->second, "" );
+}
+
+BOOST_AUTO_TEST_CASE( extract_parameters ) {
+    std::string s1 = "";
+    std::string s2 = "foo";
+    std::string s3 = " foo \r\nAbc";
+    std::string s4 = "  \r\n   foo  ";
+    std::string s5 = "foo,bar";
+    std::string s6 = "foo;bar";
+    std::string s7 = "foo;baz,bar";
+    std::string s8 = "foo;bar;baz";
+    std::string s9 = "foo;bar=baz";
+    std::string s10 = "foo;bar=baz;boo";
+    std::string s11 = "foo;bar=baz;boo,bob";
+    std::string s12 = "foo;bar=\"a b c\"";
+    std::string s13 = "foo;bar=\"a \\\"b\\\" c\"";
+
+
+    std::string sx = "foo;bar=\"a \\\"b\\\" c\"";
+    websocketpp::http::parameter_list p;
+    websocketpp::http::attribute_list a;
+    std::string::const_iterator it;
+
+    using websocketpp::http::parser::extract_parameters;
+
+    it = extract_parameters(s1.begin(),s1.end(),p);
+    BOOST_CHECK( it == s1.begin() );
+
+    p.clear();
+    it = extract_parameters(s2.begin(),s2.end(),p);
+    BOOST_CHECK( it == s2.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s3.begin(),s3.end(),p);
+    BOOST_CHECK( it == s3.begin()+5 );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s4.begin(),s4.end(),p);
+    BOOST_CHECK( it == s4.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s5.begin(),s5.end(),p);
+    BOOST_CHECK( it == s5.end() );
+    BOOST_CHECK_EQUAL( p.size(), 2 );
+    BOOST_CHECK( p[0].first == "foo" );
+    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
+    BOOST_CHECK( p[1].first == "bar" );
+    BOOST_CHECK_EQUAL( p[1].second.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s6.begin(),s6.end(),p);
+    BOOST_CHECK( it == s6.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "" );
+
+    p.clear();
+    it = extract_parameters(s7.begin(),s7.end(),p);
+    BOOST_CHECK( it == s7.end() );
+    BOOST_CHECK_EQUAL( p.size(), 2 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("baz") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("baz")->second, "" );
+    BOOST_CHECK( p[1].first == "bar" );
+    a = p[1].second;
+    BOOST_CHECK_EQUAL( a.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s8.begin(),s8.end(),p);
+    BOOST_CHECK( it == s8.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 2 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "" );
+    BOOST_CHECK( a.find("baz") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("baz")->second, "" );
+
+    p.clear();
+    it = extract_parameters(s9.begin(),s9.end(),p);
+    BOOST_CHECK( it == s9.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
+
+    p.clear();
+    it = extract_parameters(s10.begin(),s10.end(),p);
+    BOOST_CHECK( it == s10.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 2 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
+    BOOST_CHECK( a.find("boo") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("boo")->second, "" );
+
+    p.clear();
+    it = extract_parameters(s11.begin(),s11.end(),p);
+    BOOST_CHECK( it == s11.end() );
+    BOOST_CHECK_EQUAL( p.size(), 2 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 2 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
+    BOOST_CHECK( a.find("boo") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("boo")->second, "" );
+    a = p[1].second;
+    BOOST_CHECK_EQUAL( a.size(), 0 );
+
+    p.clear();
+    it = extract_parameters(s12.begin(),s12.end(),p);
+    BOOST_CHECK( it == s12.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "a b c" );
+
+    p.clear();
+    it = extract_parameters(s13.begin(),s13.end(),p);
+    BOOST_CHECK( it == s13.end() );
+    BOOST_CHECK_EQUAL( p.size(), 1 );
+    BOOST_CHECK( p[0].first == "foo" );
+    a = p[0].second;
+    BOOST_CHECK_EQUAL( a.size(), 1 );
+    BOOST_CHECK( a.find("bar") != a.end() );
+    BOOST_CHECK_EQUAL( a.find("bar")->second, "a \"b\" c" );
+}
+
+BOOST_AUTO_TEST_CASE( strip_lws ) {
+    std::string test1 = "foo";
+    std::string test2 = " foo ";
+    std::string test3 = "foo ";
+    std::string test4 = " foo";
+    std::string test5 = "    foo     ";
+    std::string test6 = "  \r\n  foo     ";
+    std::string test7 = "  \t  foo     ";
+    std::string test8 = "  \t       ";
+
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test1), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test2), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test3), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test4), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test5), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test6), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test7), "foo" );
+    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test8), "" );
+}
+
+BOOST_AUTO_TEST_CASE( case_insensitive_headers ) {
+    websocketpp::http::parser::parser r;
+
+    r.replace_header("foo","bar");
+
+    BOOST_CHECK_EQUAL( r.get_header("foo"), "bar" );
+    BOOST_CHECK_EQUAL( r.get_header("FOO"), "bar" );
+    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar" );
+}
+
+BOOST_AUTO_TEST_CASE( case_insensitive_headers_overwrite ) {
+    websocketpp::http::parser::parser r;
+
+    r.replace_header("foo","bar");
+
+    BOOST_CHECK_EQUAL( r.get_header("foo"), "bar" );
+    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar" );
+
+    r.replace_header("Foo","baz");
+
+    BOOST_CHECK_EQUAL( r.get_header("foo"), "baz" );
+    BOOST_CHECK_EQUAL( r.get_header("Foo"), "baz" );
+
+    r.remove_header("FoO");
+
+    BOOST_CHECK_EQUAL( r.get_header("foo"), "" );
+    BOOST_CHECK_EQUAL( r.get_header("Foo"), "" );
+}
+
+BOOST_AUTO_TEST_CASE( blank_consume ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "";
+
+    bool exception = false;
+
+    try {
+        r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( r.ready() == false );
+}
+
+BOOST_AUTO_TEST_CASE( blank_request ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "\r\n\r\n";
+
+    bool exception = false;
+
+    try {
+        r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == true );
+    BOOST_CHECK( r.ready() == false );
+}
+
+BOOST_AUTO_TEST_CASE( bad_request_no_host ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\n\r\n";
+
+    bool exception = false;
+
+    try {
+        r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == true );
+    BOOST_CHECK( r.ready() == false );
+}
+
+BOOST_AUTO_TEST_CASE( basic_request ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( pos == 41 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
+    BOOST_CHECK( r.get_method() == "GET" );
+    BOOST_CHECK( r.get_uri() == "/" );
+    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( trailing_body_characters ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\na";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( pos == 41 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
+    BOOST_CHECK( r.get_method() == "GET" );
+    BOOST_CHECK( r.get_uri() == "/" );
+    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( basic_split1 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\n";
+    std::string raw2 = "Host: www.example.com\r\n\r\na";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+        pos += r.consume(raw2.c_str(),raw2.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( pos == 41 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
+    BOOST_CHECK( r.get_method() == "GET" );
+    BOOST_CHECK( r.get_uri() == "/" );
+    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( basic_split2 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r";
+    std::string raw2 = "\n\r\na";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+        pos += r.consume(raw2.c_str(),raw2.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( pos == 41 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
+    BOOST_CHECK( r.get_method() == "GET" );
+    BOOST_CHECK( r.get_uri() == "/" );
+    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( max_header_len ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw(websocketpp::http::max_header_size+1,'*');
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+    } catch (const websocketpp::http::exception& e) {
+        if (e.m_error_code == websocketpp::http::status_code::request_header_fields_too_large) {
+            exception = true;
+        }
+    }
+
+    BOOST_CHECK( exception == true );
+}
+
+BOOST_AUTO_TEST_CASE( max_header_len_split ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw(websocketpp::http::max_header_size-1,'*');
+    std::string raw2(2,'*');
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+        pos += r.consume(raw2.c_str(),raw2.size());
+    } catch (const websocketpp::http::exception& e) {
+        if (e.m_error_code == websocketpp::http::status_code::request_header_fields_too_large) {
+            exception = true;
+        }
+    }
+
+    BOOST_CHECK( exception == true );
+}
+
+BOOST_AUTO_TEST_CASE( firefox_full_request ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK( pos == 482 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
+    BOOST_CHECK( r.get_method() == "GET" );
+    BOOST_CHECK( r.get_uri() == "/" );
+    BOOST_CHECK( r.get_header("Host") == "localhost:5000" );
+    BOOST_CHECK( r.get_header("User-Agent") == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0" );
+    BOOST_CHECK( r.get_header("Accept") == "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" );
+    BOOST_CHECK( r.get_header("Accept-Language") == "en-us,en;q=0.5" );
+    BOOST_CHECK( r.get_header("Accept-Encoding") == "gzip, deflate" );
+    BOOST_CHECK( r.get_header("Connection") == "keep-alive, Upgrade" );
+    BOOST_CHECK( r.get_header("Sec-WebSocket-Version") == "8" );
+    BOOST_CHECK( r.get_header("Sec-WebSocket-Origin") == "http://zaphoyd.com" );
+    BOOST_CHECK( r.get_header("Sec-WebSocket-Key") == "pFik//FxwFk0riN4ZiPFjQ==" );
+    BOOST_CHECK( r.get_header("Pragma") == "no-cache" );
+    BOOST_CHECK( r.get_header("Cache-Control") == "no-cache" );
+    BOOST_CHECK( r.get_header("Upgrade") == "websocket" );
+}
+
+BOOST_AUTO_TEST_CASE( bad_method ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GE]T / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+
+    try {
+        r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == true );
+}
+
+BOOST_AUTO_TEST_CASE( bad_header_name ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHo]st: www.example.com\r\n\r\n";
+
+    bool exception = false;
+
+    try {
+        r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == true );
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.0\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 41 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.0" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( new_http_version1 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.12\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 42 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.12" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( new_http_version2 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/12.12\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 43 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/12.12" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
+}
+
+/* commented out due to not being implemented yet
+
+BOOST_AUTO_TEST_CASE( new_http_version3 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTPS/12.12\r\nHost: www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == true );
+}*/
+
+BOOST_AUTO_TEST_CASE( header_whitespace1 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost:  www.example.com \r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 43 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( header_whitespace2 ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost:www.example.com\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 40 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
+}
+
+BOOST_AUTO_TEST_CASE( header_aggregation ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\nFoo: bar\r\nFoo: bat\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos = r.consume(raw.c_str(),raw.size());
+    } catch (...) {
+        exception = true;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 61 );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
+    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar, bat" );
+}
+
+BOOST_AUTO_TEST_CASE( wikipedia_example_response ) {
+    websocketpp::http::parser::response r;
+
+    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 159 );
+    BOOST_CHECK( r.headers_ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
+    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
+    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
+    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
+}
+
+BOOST_AUTO_TEST_CASE( response_with_non_standard_lws ) {
+    websocketpp::http::parser::response r;
+
+    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept:HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 158 );
+    BOOST_CHECK( r.headers_ready() );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
+    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
+    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
+    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
+}
+
+BOOST_AUTO_TEST_CASE( plain_http_response ) {
+    websocketpp::http::parser::response r;
+
+    std::string raw = "HTTP/1.1 200 OK\r\nDate: Thu, 10 May 2012 11:59:25 GMT\r\nServer: Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch\r\nLast-Modified: Tue, 30 Mar 2010 17:41:28 GMT\r\nETag: \"16799d-55-4830823a78200\"\r\nAccept-Ranges: bytes\r\nContent-Length: 85\r\nVary: Accept-Encoding\r\nContent-Type: text/html\r\n\r\n<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(raw.c_str(),raw.size());
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK( exception == false );
+    BOOST_CHECK_EQUAL( pos, 405 );
+    BOOST_CHECK( r.headers_ready() == true );
+    BOOST_CHECK( r.ready() == true );
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
+    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::ok );
+    BOOST_CHECK_EQUAL( r.get_status_msg(), "OK" );
+    BOOST_CHECK_EQUAL( r.get_header("Date"), "Thu, 10 May 2012 11:59:25 GMT" );
+    BOOST_CHECK_EQUAL( r.get_header("Server"), "Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch" );
+    BOOST_CHECK_EQUAL( r.get_header("Last-Modified"), "Tue, 30 Mar 2010 17:41:28 GMT" );
+    BOOST_CHECK_EQUAL( r.get_header("ETag"), "\"16799d-55-4830823a78200\"" );
+    BOOST_CHECK_EQUAL( r.get_header("Accept-Ranges"), "bytes" );
+    BOOST_CHECK_EQUAL( r.get_header("Content-Length"), "85" );
+    BOOST_CHECK_EQUAL( r.get_header("Vary"), "Accept-Encoding" );
+    BOOST_CHECK_EQUAL( r.get_header("Content-Type"), "text/html" );
+    BOOST_CHECK_EQUAL( r.get_body(), "<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>" );
+}
+
+BOOST_AUTO_TEST_CASE( parse_istream ) {
+    websocketpp::http::parser::response r;
+
+    std::stringstream s;
+
+    s << "HTTP/1.1 200 OK\r\nDate: Thu, 10 May 2012 11:59:25 GMT\r\nServer: Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch\r\nLast-Modified: Tue, 30 Mar 2010 17:41:28 GMT\r\nETag: \"16799d-55-4830823a78200\"\r\nAccept-Ranges: bytes\r\nContent-Length: 85\r\nVary: Accept-Encoding\r\nContent-Type: text/html\r\n\r\n<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>";
+
+    bool exception = false;
+    size_t pos = 0;
+
+    try {
+        pos += r.consume(s);
+    } catch (std::exception &e) {
+        exception = true;
+        std::cout << e.what() << std::endl;
+    }
+
+    BOOST_CHECK_EQUAL( exception, false );
+    BOOST_CHECK_EQUAL( pos, 405 );
+    BOOST_CHECK_EQUAL( r.headers_ready(), true );
+    BOOST_CHECK_EQUAL( r.ready(), true );
+}
+
+BOOST_AUTO_TEST_CASE( write_request_basic ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\n\r\n";
+
+    r.set_version("HTTP/1.1");
+    r.set_method("GET");
+    r.set_uri("/");
+
+    BOOST_CHECK_EQUAL( r.raw(), raw );
+}
+
+BOOST_AUTO_TEST_CASE( write_request_with_header ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "GET / HTTP/1.1\r\nHost: http://example.com\r\n\r\n";
+
+    r.set_version("HTTP/1.1");
+    r.set_method("GET");
+    r.set_uri("/");
+    r.replace_header("Host","http://example.com");
+
+    BOOST_CHECK_EQUAL( r.raw(), raw );
+}
+
+BOOST_AUTO_TEST_CASE( write_request_with_body ) {
+    websocketpp::http::parser::request r;
+
+    std::string raw = "POST / HTTP/1.1\r\nContent-Length: 48\r\nContent-Type: application/x-www-form-urlencoded\r\nHost: http://example.com\r\n\r\nlicenseID=string&content=string&paramsXML=string";
+
+    r.set_version("HTTP/1.1");
+    r.set_method("POST");
+    r.set_uri("/");
+    r.replace_header("Host","http://example.com");
+    r.replace_header("Content-Type","application/x-www-form-urlencoded");
+    r.set_body("licenseID=string&content=string&paramsXML=string");
+
+    BOOST_CHECK_EQUAL( r.raw(), raw );
+}

test/http/parser_perf.cpp

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <websocketpp/http/parser.hpp>
+
+#include <chrono>
+
+class scoped_timer {
+public:
+    scoped_timer(std::string i) : m_id(i),m_start(std::chrono::steady_clock::now()) {
+        std::cout << "Clock " << i << ": ";
+    }
+    ~scoped_timer() {
+        std::chrono::nanoseconds time_taken = std::chrono::steady_clock::now()-m_start;
+
+        //nanoseconds_per_test
+
+        //tests_per_second
+
+        //1000000000.0/(double(time_taken.count())/1000.0)
+
+        std::cout << 1000000000.0/(double(time_taken.count())/1000.0) << std::endl;
+
+        //std::cout << (1.0/double(time_taken.count())) * double(1000000000*1000) << std::endl;
+    }
+
+private:
+    std::string m_id;
+    std::chrono::steady_clock::time_point m_start;
+};
+
+int main() {
+    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
+
+    std::string firefox = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string firefox1 = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\n";
+
+    std::string firefox2 = "Accept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
+
+    {
+        scoped_timer timer("Simplest 1 chop");
+        for (int i = 0; i < 1000; i++) {
+            websocketpp::http::parser::request r;
+
+            try {
+                r.consume(raw.c_str(),raw.size());
+            } catch (...) {
+                std::cout << "exception" << std::endl;
+            }
+
+            if (!r.ready()) {
+                std::cout << "error" << std::endl;
+                break;
+            }
+        }
+    }
+
+    {
+        scoped_timer timer("FireFox, 1 chop, consume old");
+        for (int i = 0; i < 1000; i++) {
+            websocketpp::http::parser::request r;
+
+            try {
+                r.consume2(firefox.c_str(),firefox.size());
+            } catch (...) {
+                std::cout << "exception" << std::endl;
+            }
+
+            if (!r.ready()) {
+                std::cout << "error" << std::endl;
+                break;
+            }
+        }
+    }
+
+    {
+        scoped_timer timer("FireFox, 1 chop");
+        for (int i = 0; i < 1000; i++) {
+            websocketpp::http::parser::request r;
+
+            try {
+                r.consume(firefox.c_str(),firefox.size());
+            } catch (...) {
+                std::cout << "exception" << std::endl;
+            }
+
+            if (!r.ready()) {
+                std::cout << "error" << std::endl;
+                break;
+            }
+        }
+    }
+
+
+
+    {
+        scoped_timer timer("FireFox, 2 chop");
+        for (int i = 0; i < 1000; i++) {
+            websocketpp::http::parser::request r;
+
+            try {
+                r.consume(firefox1.c_str(),firefox1.size());
+                r.consume(firefox2.c_str(),firefox2.size());
+            } catch (...) {
+                std::cout << "exception" << std::endl;
+            }
+
+            if (!r.ready()) {
+                std::cout << "error" << std::endl;
+                break;
+            }
+        }
+    }
+
+    return 0;
+}

test/logger/SConscript

@@ -0,0 +1,23 @@
+## logger unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
+
+objs = env.Object('logger_basic_boost.o', ["basic.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('logger_basic_boost', ["logger_basic_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('logger_basic_stl.o', ["basic.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('logger_basic_stl', ["logger_basic_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/logger/basic.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE basic_log
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+#include <websocketpp/logger/basic.hpp>
+#include <websocketpp/concurrency/none.hpp>
+#include <websocketpp/concurrency/basic.hpp>
+
+BOOST_AUTO_TEST_CASE( is_token_char ) {
+    typedef websocketpp::log::basic<websocketpp::concurrency::none,websocketpp::log::elevel> error_log;
+
+    error_log elog;
+
+    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::info ) == true );
+    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::warn ) == true );
+    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::rerror ) == true );
+    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::fatal ) == true );
+
+    elog.set_channels(websocketpp::log::elevel::info);
+
+    elog.write(websocketpp::log::elevel::info,"Information");
+    elog.write(websocketpp::log::elevel::warn,"A warning");
+    elog.write(websocketpp::log::elevel::rerror,"A error");
+    elog.write(websocketpp::log::elevel::fatal,"A critical error");
+}
+
+BOOST_AUTO_TEST_CASE( access_clear ) {
+    typedef websocketpp::log::basic<websocketpp::concurrency::none,websocketpp::log::alevel> access_log;
+
+    std::stringstream out;
+    access_log logger(0xffffffff,&out);
+
+    // clear all channels
+    logger.clear_channels(0xffffffff);
+
+    // writes shouldn't happen
+    logger.write(websocketpp::log::alevel::devel,"devel");
+    //std::cout << "|" << out.str() << "|" << std::endl;
+    BOOST_CHECK( out.str().size() == 0 );
+}
+
+BOOST_AUTO_TEST_CASE( basic_concurrency ) {
+    typedef websocketpp::log::basic<websocketpp::concurrency::basic,websocketpp::log::alevel> access_log;
+
+    std::stringstream out;
+    access_log logger(0xffffffff,&out);
+
+    logger.set_channels(0xffffffff);
+
+    logger.write(websocketpp::log::alevel::devel,"devel");
+    //std::cout << "|" << out.str() << "|" << std::endl;
+    BOOST_CHECK( out.str().size() > 0 );
+}

test/message_buffer/SConscript

@@ -0,0 +1,27 @@
+## message_buffer unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
+
+objs = env.Object('message_boost.o', ["message.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('alloc_boost.o', ["alloc.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_message_boost', ["message_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_alloc_boost', ["alloc_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('message_stl.o', ["message.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('alloc_stl.o', ["alloc.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_message_stl', ["message_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_alloc_stl', ["alloc_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/message_buffer/alloc.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE message_buffer_alloc
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/message_buffer/alloc.hpp>
+
+template <template <class> class con_msg_manager>
+struct stub {
+    typedef websocketpp::lib::shared_ptr<stub> ptr;
+
+    typedef con_msg_manager<stub> con_msg_man_type;
+    typedef typename con_msg_man_type::ptr con_msg_man_ptr;
+    typedef typename con_msg_man_type::weak_ptr con_msg_man_weak_ptr;
+
+    stub(con_msg_man_ptr manager, websocketpp::frame::opcode::value op, size_t size = 128)
+      : m_opcode(op)
+      , m_manager(manager)
+      , m_size(size) {}
+
+    bool recycle() {
+        con_msg_man_ptr shared = m_manager.lock();
+
+        if (shared) {
+            return shared->recycle(this);
+        } else {
+            return false;
+        }
+    }
+
+    websocketpp::frame::opcode::value   m_opcode;
+    con_msg_man_weak_ptr                m_manager;
+    size_t                              m_size;
+};
+
+BOOST_AUTO_TEST_CASE( basic_get_message ) {
+    typedef stub<websocketpp::message_buffer::alloc::con_msg_manager>
+        message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_man_type;
+
+    con_msg_man_type::ptr manager(new con_msg_man_type());
+    message_type::ptr msg = manager->get_message(websocketpp::frame::opcode::TEXT,512);
+
+    BOOST_CHECK(msg);
+    BOOST_CHECK(msg->m_opcode == websocketpp::frame::opcode::TEXT);
+    BOOST_CHECK(msg->m_manager.lock() == manager);
+    BOOST_CHECK(msg->m_size == 512);
+}
+
+BOOST_AUTO_TEST_CASE( basic_get_manager ) {
+    typedef stub<websocketpp::message_buffer::alloc::con_msg_manager>
+        message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_man_type;
+    typedef websocketpp::message_buffer::alloc::endpoint_msg_manager
+        <con_msg_man_type> endpoint_manager_type;
+
+    endpoint_manager_type em;
+    con_msg_man_type::ptr manager = em.get_manager();
+    message_type::ptr msg = manager->get_message(websocketpp::frame::opcode::TEXT,512);
+
+    BOOST_CHECK(msg);
+    BOOST_CHECK(msg->m_opcode == websocketpp::frame::opcode::TEXT);
+    BOOST_CHECK(msg->m_manager.lock() == manager);
+    BOOST_CHECK(msg->m_size == 512);
+}
+

test/message_buffer/message.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE message
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/message_buffer/message.hpp>
+
+template <typename message>
+struct stub {
+    typedef websocketpp::lib::weak_ptr<stub> weak_ptr;
+    typedef websocketpp::lib::shared_ptr<stub> ptr;
+
+    stub() : recycled(false) {}
+
+    bool recycle(message *) {
+        this->recycled = true;
+        return false;
+    }
+
+    bool recycled;
+};
+
+BOOST_AUTO_TEST_CASE( basic_size_check ) {
+    typedef websocketpp::message_buffer::message<stub> message_type;
+    typedef stub<message_type> stub_type;
+
+    stub_type::ptr s(new stub_type());
+    message_type::ptr msg(new message_type(s,websocketpp::frame::opcode::TEXT,500));
+
+    BOOST_CHECK(msg->get_payload().capacity() >= 500);
+}
+
+BOOST_AUTO_TEST_CASE( recycle ) {
+    typedef websocketpp::message_buffer::message<stub> message_type;
+    typedef stub<message_type> stub_type;
+
+    stub_type::ptr s(new stub_type());
+    message_type::ptr msg(new message_type(s,websocketpp::frame::opcode::TEXT,500));
+
+    BOOST_CHECK(s->recycled == false);
+    BOOST_CHECK(msg->recycle() == false);
+    BOOST_CHECK(s->recycled == true);
+}
+

test/message_buffer/pool.cpp

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_00_processor
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/hybi00.hpp>
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    websocketpp::http::parser::request r;
+    websocketpp::http::parser::response response;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","WjN}|M(6");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(p.validate_handshake(r));
+
+    websocketpp::uri_ptr u;
+    bool exception;
+
+    try {
+        u = p.get_uri(r);
+    } catch (const websocketpp::uri_exception& e) {
+        exception = true;
+    }
+
+    BOOST_CHECK(exception == false);
+    BOOST_CHECK(u->get_secure() == false);
+    BOOST_CHECK(u->get_host() == "www.example.com");
+    BOOST_CHECK(u->get_resource() == "/");
+    BOOST_CHECK(u->get_port() == websocketpp::URI_DEFAULT_PORT);
+
+    p.process_handshake(r,response);
+
+    BOOST_CHECK(response.get_header("Connection") == "Upgrade");
+    BOOST_CHECK(response.get_header("Upgrade") == "websocket");
+    BOOST_CHECK(response.get_header("Sec-WebSocket-Origin") == "http://example.com");
+
+    BOOST_CHECK(response.get_header("Sec-WebSocket-Location") == "ws://www.example.com/");
+    BOOST_CHECK(response.get_header("Sec-WebSocket-Key3") == "n`9eBk9z$R8pOtVb");
+}
+
+BOOST_AUTO_TEST_CASE( non_get_method ) {
+    websocketpp::http::parser::request r;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+
+    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(!p.validate_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    websocketpp::http::parser::request r;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+
+    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(!p.validate_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
+    websocketpp::http::parser::request r;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(!p.validate_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
+    websocketpp::http::parser::request r;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(!p.validate_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( bad_host ) {
+    websocketpp::http::parser::request r;
+    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
+    websocketpp::uri_ptr u;
+    bool exception = false;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+    r.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    BOOST_CHECK(!p.validate_handshake(r));
+
+    try {
+        u = p.get_uri(r);
+    } catch (const websocketpp::uri_exception& e) {
+        exception = true;
+    }
+
+    BOOST_CHECK(exception == true);
+}

test/processors/SConscript

@@ -0,0 +1,47 @@
+## processor unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + ['z']
+
+objs = env.Object('test_processor_boost.o', ["processor.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('test_hybi13_boost.o', ["hybi13.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('test_hybi08_boost.o', ["hybi08.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('test_hybi07_boost.o', ["hybi07.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('test_hybi00_boost.o', ["hybi00.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('test_extension_permessage_compress_boost.o', ["extension_permessage_compress.cpp"], LIBS = BOOST_LIBS)
+
+prgs = env.Program('test_processor_boost', ["test_processor_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_hybi13_boost', ["test_hybi13_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_hybi08_boost', ["test_hybi08_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_hybi07_boost', ["test_hybi07_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_hybi00_boost', ["test_hybi00_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_extension_permessage_compress_boost', ["test_extension_permessage_compress_boost.o"], LIBS = BOOST_LIBS + ['z'])
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
+   # no C++11 features are used in processor so there are no C++11 versions of
+   # these tests.
+   objs += env_cpp11.Object('test_processor_stl.o', ["processor.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('test_hybi13_stl.o', ["hybi13.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('test_hybi08_stl.o', ["hybi08.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('test_hybi07_stl.o', ["hybi07.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('test_hybi00_stl.o', ["hybi00.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('test_extension_permessage_compress_stl.o', ["extension_permessage_compress.cpp"], LIBS = BOOST_LIBS_CPP11 + ['z'])
+
+   prgs += env_cpp11.Program('test_processor_stl', ["test_processor_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_hybi13_stl', ["test_hybi13_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_hybi08_stl', ["test_hybi08_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_hybi07_stl', ["test_hybi07_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_hybi00_stl', ["test_hybi00_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_extension_permessage_compress_stl', ["test_extension_permessage_compress_stl.o"], LIBS = BOOST_LIBS_CPP11 + ['z'])
+
+Return('prgs')

test/processors/extension_permessage_compress.cpp

@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE extension_permessage_deflate
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+#include <websocketpp/common/memory.hpp>
+
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
+
+struct config {
+    typedef websocketpp::http::parser::request request_type;
+};
+typedef websocketpp::extensions::permessage_deflate::enabled<config>
+    compressor_type;
+
+using namespace websocketpp;
+
+BOOST_AUTO_TEST_CASE( deflate_init ) {
+    /*compressor_type compressor;
+    websocketpp::http::parser::attribute_list attributes;
+    std::pair<lib::error_code,std::string> neg_ret;
+
+    neg_ret = compressor.negotiate(attributes);
+
+    BOOST_CHECK_EQUAL( neg_ret.first,
+        extensions::permessage_deflate::error::invalid_parameters );*/
+
+    /**
+     * Window size is primarily controlled by the writer. A stream can only be
+     * read by a window size equal to or greater than the one use to compress
+     * it initially. The default windows size is also the maximum window size.
+     * Thus:
+     *
+     * Outbound window size can be limited unilaterally under the assumption
+     * that the opposite end will be using the default (maximum size which can
+     * read anything)
+     *
+     * Inbound window size must be limited by asking the remote endpoint to
+     * do so and it agreeing.
+     *
+     * Context takeover is also primarily controlled by the writer. If the
+     * compressor does not clear its context between messages then the reader
+     * can't either.
+     *
+     * Outbound messages may clear context between messages unilaterally.
+     * Inbound messages must retain state unless the remote endpoint signals
+     * otherwise.
+     *
+     * Negotiation options:
+     * Client must choose from the following options:
+     * - whether or not to request an inbound window limit
+     * - whether or not to signal that it will honor an outbound window limit
+     * - whether or not to request that the server disallow context takeover
+     *
+     * Server must answer in the following ways
+     * - If client requested a window size limit, is the window size limit
+     *   acceptable?
+     * - If client allows window limit requests, should we send one?
+     * - If client requested no context takeover, should we accept?
+     *
+     *
+     *
+     * All Defaults
+     * Req: permessage-compress; method=deflate
+     * Ans: permessage-compress; method=deflate
+     *
+     * # Client wants to limit the size of inbound windows from server
+     * permessage-compress; method="deflate; s2c_max_window_bits=8, deflate"
+     * Ans: permessage-compress; method="deflate; s2c_max_window_bits=8"
+     * OR
+     * Ans: permessage-compress; method=deflate
+     *
+     * # Server wants to limit the size of inbound windows from client
+     * Client:
+     * permessage-compress; method="deflate; c2s_max_window_bits, deflate"
+     *
+     * Server:
+     * permessage-compress; method="deflate; c2s_max_window_bits=8"
+     *
+     * # Client wants to
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+
+
+
+
+   /* processor::extensions::deflate_method d(true);
+    http::parser::attribute_list attributes;
+    lib::error_code ec;
+
+    attributes.push_back(http::parser::attribute("foo","bar"));
+    ec = d.init(attributes);
+    BOOST_CHECK(ec == processor::extensions::error::unknown_method_parameter);
+
+    attributes.clear();
+    attributes.push_back(http::parser::attribute("s2c_max_window_bits","bar"));
+    ec = d.init(attributes);
+    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
+
+    attributes.clear();
+    attributes.push_back(http::parser::attribute("s2c_max_window_bits","7"));
+    ec = d.init(attributes);
+    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
+
+    attributes.clear();
+    attributes.push_back(http::parser::attribute("s2c_max_window_bits","16"));
+    ec = d.init(attributes);
+    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
+
+    attributes.clear();
+    attributes.push_back(http::parser::attribute("s2c_max_window_bits","9"));
+    ec = d.init(attributes);
+    BOOST_CHECK( !ec);
+
+    attributes.clear();
+    ec = d.init(attributes);
+    BOOST_CHECK( !ec);
+
+    processor::extensions::deflate_engine de;
+
+    unsigned char test_in[] = "HelloHelloHelloHello";
+    unsigned char test_out[30];
+
+    uLongf test_out_size = 30;
+
+    int ret;
+
+    ret = compress(test_out, &test_out_size, test_in, 20);
+
+    std::cout << ret << std::endl
+              << websocketpp::utility::to_hex(test_in,20) << std::endl
+              << websocketpp::utility::to_hex(test_out,test_out_size) << std::endl;
+
+    std::string input = "Hello";
+    std::string output = "";
+    ec = de.compress(input,output);
+
+    BOOST_CHECK( ec == processor::extensions::error::uninitialized );
+
+    //std::cout << ec.message() << websocketpp::utility::to_hex(output) << std::endl;
+
+    ec = de.init(15,15,Z_DEFAULT_COMPRESSION,8,Z_FIXED);
+    //ec = de.init();
+    BOOST_CHECK( !ec );
+
+    ec = de.compress(input,output);
+    std::cout << ec.message() << std::endl
+              << websocketpp::utility::to_hex(input) << std::endl
+              << websocketpp::utility::to_hex(output) << std::endl;
+
+    output = "";
+
+    ec = de.compress(input,output);
+    std::cout << ec.message() << std::endl
+              << websocketpp::utility::to_hex(input) << std::endl
+              << websocketpp::utility::to_hex(output) << std::endl;
+
+    input = output;
+    output = "";
+    ec = de.decompress(input,output);
+    std::cout << ec.message() << std::endl
+              << websocketpp::utility::to_hex(input) << std::endl
+              << websocketpp::utility::to_hex(output) << std::endl;
+    */
+}

test/processors/hybi00.cpp

@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_00_processor
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/hybi00.hpp>
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+#include <websocketpp/message_buffer/message.hpp>
+#include <websocketpp/message_buffer/alloc.hpp>
+
+struct stub_config {
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+
+    typedef websocketpp::message_buffer::message
+        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_manager_type;
+        
+    static const size_t max_message_size = 16000000;
+};
+
+struct processor_setup {
+    processor_setup(bool server)
+      : msg_manager(new stub_config::con_msg_manager_type())
+      , p(false,server,msg_manager) {}
+
+    websocketpp::lib::error_code ec;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::request_type req;
+    stub_config::response_type res;
+    websocketpp::processor::hybi00<stub_config> p;
+};
+
+typedef stub_config::message_type::ptr message_ptr;
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","WjN}|M(6");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    env.ec = env.p.validate_handshake(env.req);
+    BOOST_CHECK(!env.ec);
+
+    websocketpp::uri_ptr u;
+
+    BOOST_CHECK_NO_THROW( u = env.p.get_uri(env.req) );
+
+    BOOST_CHECK_EQUAL(u->get_secure(), false);
+    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
+    BOOST_CHECK_EQUAL(u->get_resource(), "/");
+    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
+
+    env.p.process_handshake(env.req,"",env.res);
+
+    BOOST_CHECK_EQUAL(env.res.get_header("Connection"), "Upgrade");
+    BOOST_CHECK_EQUAL(env.res.get_header("Upgrade"), "WebSocket");
+    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Origin"), "http://example.com");
+
+    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Location"), "ws://www.example.com/");
+    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Key3"), "n`9eBk9z$R8pOtVb");
+}
+
+BOOST_AUTO_TEST_CASE( non_get_method ) {
+    processor_setup env(true);
+
+    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_method );
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_version );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( bad_host ) {
+    processor_setup env(true);
+    websocketpp::uri_ptr u;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK( !env.p.validate_handshake(env.req) );
+
+    BOOST_CHECK( !env.p.get_uri(env.req)->get_valid() );
+}
+
+BOOST_AUTO_TEST_CASE( extract_subprotocols ) {
+    processor_setup env(true);
+
+    std::vector<std::string> subps;
+
+    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
+    BOOST_CHECK_EQUAL( subps.size(), 0 );
+}
+
+BOOST_AUTO_TEST_CASE( prepare_data_frame_null ) {
+    processor_setup env(true);
+
+    message_ptr in = env.msg_manager->get_message();
+    message_ptr out = env.msg_manager->get_message();
+    message_ptr invalid;
+
+
+    // empty pointers arguements should return sane error
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,invalid), websocketpp::processor::error::invalid_arguments );
+
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(in,invalid), websocketpp::processor::error::invalid_arguments );
+
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,out), websocketpp::processor::error::invalid_arguments );
+
+    // test valid opcodes
+    // text (1) should be the only valid opcode
+    for (int i = 0; i < 0xF; i++) {
+        in->set_opcode(websocketpp::frame::opcode::value(i));
+
+        env.ec = env.p.prepare_data_frame(in,out);
+
+        if (i != 1) {
+            BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode );
+        } else {
+            BOOST_CHECK_NE( env.ec, websocketpp::processor::error::invalid_opcode );
+        }
+    }
+
+    /*
+     * TODO: tests for invalid UTF8
+    char buf[2] = {0x00, 0x00};
+
+    in->set_opcode(websocketpp::frame::opcode::text);
+    in->set_payload("foo");
+
+    env.ec = env.p.prepare_data_frame(in,out);
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_payload );
+    */
+}
+
+BOOST_AUTO_TEST_CASE( prepare_data_frame ) {
+    processor_setup env(true);
+
+    message_ptr in = env.msg_manager->get_message();
+    message_ptr out = env.msg_manager->get_message();
+
+    in->set_opcode(websocketpp::frame::opcode::text);
+    in->set_payload("foo");
+
+    env.ec = env.p.prepare_data_frame(in,out);
+
+    unsigned char raw_header[1] = {0x00};
+    unsigned char raw_payload[4] = {0x66,0x6f,0x6f,0xff};
+
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( out->get_header(), std::string(reinterpret_cast<char*>(raw_header),1) );
+    BOOST_CHECK_EQUAL( out->get_payload(), std::string(reinterpret_cast<char*>(raw_payload),4) );
+}
+
+
+BOOST_AUTO_TEST_CASE( empty_consume ) {
+    uint8_t frame[2] = {0x00,0x00};
+
+    processor_setup env(true);
+
+    size_t ret = env.p.consume(frame,0,env.ec);
+
+    BOOST_CHECK_EQUAL( ret, 0);
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( empty_frame ) {
+    uint8_t frame[2] = {0x00, 0xff};
+
+    processor_setup env(true);
+
+    size_t ret = env.p.consume(frame,2,env.ec);
+
+    BOOST_CHECK_EQUAL( ret, 2);
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "" );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( short_frame ) {
+    uint8_t frame[5] = {0x00, 0x66, 0x6f, 0x6f, 0xff};
+
+    processor_setup env(true);
+
+    size_t ret = env.p.consume(frame,5,env.ec);
+
+    BOOST_CHECK_EQUAL( ret, 5);
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "foo" );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}

test/processors/hybi07.cpp

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_07_processor
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/hybi07.hpp>
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+#include <websocketpp/message_buffer/message.hpp>
+#include <websocketpp/message_buffer/alloc.hpp>
+#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
+#include <websocketpp/random/none.hpp>
+
+struct stub_config {
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+
+    typedef websocketpp::message_buffer::message
+        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_manager_type;
+
+    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
+
+    static const size_t max_message_size = 16000000;
+
+    /// Extension related config
+    static const bool enable_extensions = false;
+
+    /// Extension specific config
+
+    /// permessage_compress_config
+    struct permessage_deflate_config {
+        typedef stub_config::request_type request_type;
+    };
+
+    typedef websocketpp::extensions::permessage_deflate::disabled
+        <permessage_deflate_config> permessage_deflate_type;
+};
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK(!ec);
+
+    websocketpp::uri_ptr u;
+
+    u = p.get_uri(r);
+
+    BOOST_CHECK(u->get_valid());
+    BOOST_CHECK(!u->get_secure());
+    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
+    BOOST_CHECK_EQUAL(u->get_resource(), "/");
+    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
+
+    p.process_handshake(r,"",response);
+
+    BOOST_CHECK_EQUAL(response.get_header("Connection"), "upgrade");
+    BOOST_CHECK_EQUAL(response.get_header("Upgrade"), "websocket");
+    BOOST_CHECK_EQUAL(response.get_header("Sec-WebSocket-Accept"), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
+}
+
+BOOST_AUTO_TEST_CASE( non_get_method ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_method );
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_version );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( bad_host ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( !ec );
+
+    BOOST_CHECK( !p.get_uri(r)->get_valid() );
+}

test/processors/hybi08.cpp

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_08_processor
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/hybi08.hpp>
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+#include <websocketpp/message_buffer/message.hpp>
+#include <websocketpp/message_buffer/alloc.hpp>
+#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
+#include <websocketpp/random/none.hpp>
+
+struct stub_config {
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+
+    typedef websocketpp::message_buffer::message
+        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_manager_type;
+
+    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
+
+    static const size_t max_message_size = 16000000;
+
+    /// Extension related config
+    static const bool enable_extensions = false;
+
+    /// Extension specific config
+
+    /// permessage_deflate_config
+    struct permessage_deflate_config {
+        typedef stub_config::request_type request_type;
+    };
+
+    typedef websocketpp::extensions::permessage_deflate::disabled
+        <permessage_deflate_config> permessage_deflate_type;
+};
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK(!ec);
+
+    websocketpp::uri_ptr u;
+
+    u = p.get_uri(r);
+
+    BOOST_CHECK(u->get_valid() == true);
+    BOOST_CHECK(u->get_secure() == false);
+    BOOST_CHECK(u->get_host() == "www.example.com");
+    BOOST_CHECK(u->get_resource() == "/");
+    BOOST_CHECK(u->get_port() == websocketpp::uri_default_port);
+
+    p.process_handshake(r,"",response);
+
+    BOOST_CHECK(response.get_header("Connection") == "upgrade");
+    BOOST_CHECK(response.get_header("Upgrade") == "websocket");
+    BOOST_CHECK(response.get_header("Sec-WebSocket-Accept") == "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
+}
+
+BOOST_AUTO_TEST_CASE( non_get_method ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::rng_type rng;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_method );
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_version );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( bad_host ) {
+    stub_config::request_type r;
+    stub_config::response_type response;
+    stub_config::con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
+    websocketpp::uri_ptr u;
+    websocketpp::lib::error_code ec;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
+    ec = p.validate_handshake(r);
+    BOOST_CHECK( !ec );
+
+    u = p.get_uri(r);
+
+    BOOST_CHECK( !u->get_valid() );
+}
+

test/processors/hybi13.cpp

@@ -0,0 +1,693 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_13_processor
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/hybi13.hpp>
+
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+#include <websocketpp/message_buffer/message.hpp>
+#include <websocketpp/message_buffer/alloc.hpp>
+#include <websocketpp/random/none.hpp>
+
+#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
+#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
+
+struct stub_config {
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+
+    typedef websocketpp::message_buffer::message
+        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_manager_type;
+
+    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
+
+    struct permessage_deflate_config {
+        typedef stub_config::request_type request_type;
+    };
+
+    typedef websocketpp::extensions::permessage_deflate::disabled
+        <permessage_deflate_config> permessage_deflate_type;
+
+    static const size_t max_message_size = 16000000;
+    static const bool enable_extensions = false;
+};
+
+struct stub_config_ext {
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+
+    typedef websocketpp::message_buffer::message
+        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
+    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
+        con_msg_manager_type;
+
+    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
+
+    struct permessage_deflate_config {
+        typedef stub_config_ext::request_type request_type;
+    };
+
+    typedef websocketpp::extensions::permessage_deflate::enabled
+        <permessage_deflate_config> permessage_deflate_type;
+
+    static const size_t max_message_size = 16000000;
+    static const bool enable_extensions = true;
+};
+
+typedef stub_config::con_msg_manager_type con_msg_manager_type;
+typedef stub_config::message_type::ptr message_ptr;
+
+// Set up a structure that constructs new copies of all of the support structure
+// for using connection processors
+struct processor_setup {
+    processor_setup(bool server)
+      : msg_manager(new con_msg_manager_type())
+      , p(false,server,msg_manager,rng) {}
+
+    websocketpp::lib::error_code ec;
+    con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    stub_config::request_type req;
+    stub_config::response_type res;
+    websocketpp::processor::hybi13<stub_config> p;
+};
+
+struct processor_setup_ext {
+    processor_setup_ext(bool server)
+      : msg_manager(new con_msg_manager_type())
+      , p(false,server,msg_manager,rng) {}
+
+    websocketpp::lib::error_code ec;
+    con_msg_manager_type::ptr msg_manager;
+    stub_config::rng_type rng;
+    stub_config::request_type req;
+    stub_config::response_type res;
+    websocketpp::processor::hybi13<stub_config_ext> p;
+};
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK(!env.p.validate_handshake(env.req));
+
+    websocketpp::uri_ptr u;
+
+    BOOST_CHECK_NO_THROW( u = env.p.get_uri(env.req) );
+
+    BOOST_CHECK_EQUAL(u->get_secure(), false);
+    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
+    BOOST_CHECK_EQUAL(u->get_resource(), "/");
+    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
+
+    env.p.process_handshake(env.req,"",env.res);
+
+    BOOST_CHECK_EQUAL(env.res.get_header("Connection"), "upgrade");
+    BOOST_CHECK_EQUAL(env.res.get_header("Upgrade"), "websocket");
+    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Accept"), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
+}
+
+BOOST_AUTO_TEST_CASE( non_get_method ) {
+    processor_setup env(true);
+
+    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK( env.p.validate_handshake(env.req) == websocketpp::processor::error::invalid_http_method );
+}
+
+BOOST_AUTO_TEST_CASE( old_http_version ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
+    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_version );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
+    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
+    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
+    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( bad_host ) {
+    processor_setup env(true);
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
+
+    env.req.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
+    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
+    BOOST_CHECK( !env.p.validate_handshake(env.req) );
+    BOOST_CHECK( !env.p.get_uri(env.req)->get_valid() );
+}
+
+// FRAME TESTS TO DO
+//
+// unmasked, 0 length, binary
+// 0x82 0x00
+//
+// masked, 0 length, binary
+// 0x82 0x80
+//
+// unmasked, 0 length, text
+// 0x81 0x00
+//
+// masked, 0 length, text
+// 0x81 0x80
+
+BOOST_AUTO_TEST_CASE( frame_empty_binary_unmasked ) {
+    uint8_t frame[2] = {0x82, 0x00};
+
+    // all in one chunk
+    processor_setup env1(false);
+
+    size_t ret1 = env1.p.consume(frame,2,env1.ec);
+
+    BOOST_CHECK_EQUAL( ret1, 2 );
+    BOOST_CHECK( !env1.ec );
+    BOOST_CHECK_EQUAL( env1.p.ready(), true );
+
+    // two separate chunks
+    processor_setup env2(false);
+
+    BOOST_CHECK_EQUAL( env2.p.consume(frame,1,env2.ec), 1 );
+    BOOST_CHECK( !env2.ec );
+    BOOST_CHECK_EQUAL( env2.p.ready(), false );
+
+    BOOST_CHECK_EQUAL( env2.p.consume(frame+1,1,env2.ec), 1 );
+    BOOST_CHECK( !env2.ec );
+    BOOST_CHECK_EQUAL( env2.p.ready(), true );
+}
+
+BOOST_AUTO_TEST_CASE( frame_small_binary_unmasked ) {
+    processor_setup env(false);
+
+    uint8_t frame[4] = {0x82, 0x02, 0x2A, 0x2A};
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env.p.consume(frame,4,env.ec), 4 );
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+
+    message_ptr foo = env.p.get_message();
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( foo->get_payload(), "**" );
+
+}
+
+BOOST_AUTO_TEST_CASE( frame_extended_binary_unmasked ) {
+    processor_setup env(false);
+
+    uint8_t frame[130] = {0x82, 0x7E, 0x00, 0x7E};
+    frame[0] = 0x82;
+    frame[1] = 0x7E;
+    frame[2] = 0x00;
+    frame[3] = 0x7E;
+    std::fill_n(frame+4,126,0x2A);
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env.p.consume(frame,130,env.ec), 130 );
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+
+    message_ptr foo = env.p.get_message();
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( foo->get_payload().size(), 126 );
+}
+
+BOOST_AUTO_TEST_CASE( frame_jumbo_binary_unmasked ) {
+    processor_setup env(false);
+
+    uint8_t frame[130] = {0x82, 0x7E, 0x00, 0x7E};
+    std::fill_n(frame+4,126,0x2A);
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env.p.consume(frame,130,env.ec), 130 );
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+
+    message_ptr foo = env.p.get_message();
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( foo->get_payload().size(), 126 );
+}
+
+BOOST_AUTO_TEST_CASE( control_frame_too_large ) {
+    processor_setup env(false);
+
+    uint8_t frame[130] = {0x88, 0x7E, 0x00, 0x7E};
+    std::fill_n(frame+4,126,0x2A);
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_GT( env.p.consume(frame,130,env.ec), 0 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::control_too_big  );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( rsv_bits_used ) {
+    uint8_t frame[3][2] = {{0x90, 0x00},
+                           {0xA0, 0x00},
+                           {0xC0, 0x00}};
+
+    for (int i = 0; i < 3; i++) {
+        processor_setup env(false);
+
+        BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+        BOOST_CHECK_GT( env.p.consume(frame[i],2,env.ec), 0 );
+        BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_rsv_bit  );
+        BOOST_CHECK_EQUAL( env.p.ready(), false );
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE( reserved_opcode_used ) {
+    uint8_t frame[10][2] = {{0x83, 0x00},
+                            {0x84, 0x00},
+                            {0x85, 0x00},
+                            {0x86, 0x00},
+                            {0x87, 0x00},
+                            {0x8B, 0x00},
+                            {0x8C, 0x00},
+                            {0x8D, 0x00},
+                            {0x8E, 0x00},
+                            {0x8F, 0x00}};
+
+    for (int i = 0; i < 10; i++) {
+        processor_setup env(false);
+
+        BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+        BOOST_CHECK_GT( env.p.consume(frame[i],2,env.ec), 0 );
+        BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode  );
+        BOOST_CHECK_EQUAL( env.p.ready(), false );
+    }
+}
+
+BOOST_AUTO_TEST_CASE( fragmented_control_message ) {
+    processor_setup env(false);
+
+    uint8_t frame[2] = {0x08, 0x00};
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_GT( env.p.consume(frame,2,env.ec), 0 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::fragmented_control );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( fragmented_binary_message ) {
+    processor_setup env0(false);
+    processor_setup env1(false);
+
+    uint8_t frame0[6] = {0x02, 0x01, 0x2A, 0x80, 0x01, 0x2A};
+    uint8_t frame1[8] = {0x02, 0x01, 0x2A, 0x89, 0x00, 0x80, 0x01, 0x2A};
+
+    // read fragmented message in one chunk
+    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env0.p.consume(frame0,6,env0.ec), 6 );
+    BOOST_CHECK( !env0.ec );
+    BOOST_CHECK_EQUAL( env0.p.ready(), true );
+    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
+
+    // read fragmented message in two chunks
+    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env0.p.consume(frame0,3,env0.ec), 3 );
+    BOOST_CHECK( !env0.ec );
+    BOOST_CHECK_EQUAL( env0.p.ready(), false );
+    BOOST_CHECK_EQUAL( env0.p.consume(frame0+3,3,env0.ec), 3 );
+    BOOST_CHECK( !env0.ec );
+    BOOST_CHECK_EQUAL( env0.p.ready(), true );
+    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
+
+    // read fragmented message with control message in between
+    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env0.p.consume(frame1,8,env0.ec), 5 );
+    BOOST_CHECK( !env0.ec );
+    BOOST_CHECK_EQUAL( env0.p.ready(), true );
+    BOOST_CHECK_EQUAL( env0.p.get_message()->get_opcode(), websocketpp::frame::opcode::PING);
+    BOOST_CHECK_EQUAL( env0.p.consume(frame1+5,3,env0.ec), 3 );
+    BOOST_CHECK( !env0.ec );
+    BOOST_CHECK_EQUAL( env0.p.ready(), true );
+    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
+
+    // read lone continuation frame
+    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
+    BOOST_CHECK_GT( env0.p.consume(frame0+3,3,env0.ec), 0);
+    BOOST_CHECK_EQUAL( env0.ec, websocketpp::processor::error::invalid_continuation );
+
+    // read two start frames in a row
+    BOOST_CHECK_EQUAL( env1.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env1.p.consume(frame0,3,env1.ec), 3);
+    BOOST_CHECK( !env1.ec );
+    BOOST_CHECK_GT( env1.p.consume(frame0,3,env1.ec), 0);
+    BOOST_CHECK_EQUAL( env1.ec, websocketpp::processor::error::invalid_continuation );
+}
+
+BOOST_AUTO_TEST_CASE( unmasked_client_frame ) {
+    processor_setup env(true);
+
+    uint8_t frame[2] = {0x82, 0x00};
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_GT( env.p.consume(frame,2,env.ec), 0 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::masking_required );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( masked_server_frame ) {
+    processor_setup env(false);
+
+    uint8_t frame[8] = {0x82, 0x82, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0xD5};
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_GT( env.p.consume(frame,8,env.ec), 0 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::masking_forbidden );
+    BOOST_CHECK_EQUAL( env.p.ready(), false );
+}
+
+BOOST_AUTO_TEST_CASE( frame_small_binary_masked ) {
+    processor_setup env(true);
+
+    uint8_t frame[8] = {0x82, 0x82, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0xD5};
+
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env.p.consume(frame,8,env.ec), 8 );
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "**" );
+}
+
+BOOST_AUTO_TEST_CASE( masked_fragmented_binary_message ) {
+    processor_setup env(true);
+
+    uint8_t frame0[14] = {0x02, 0x81, 0xAB, 0x23, 0x98, 0x45, 0x81,
+                         0x80, 0x81, 0xB8, 0x34, 0x12, 0xFF, 0x92};
+
+    // read fragmented message in one chunk
+    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
+    BOOST_CHECK_EQUAL( env.p.consume(frame0,14,env.ec), 14 );
+    BOOST_CHECK( !env.ec );
+    BOOST_CHECK_EQUAL( env.p.ready(), true );
+    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "**" );
+}
+
+BOOST_AUTO_TEST_CASE( prepare_data_frame ) {
+    processor_setup env(true);
+
+    message_ptr in = env.msg_manager->get_message();
+    message_ptr out = env.msg_manager->get_message();
+    message_ptr invalid;
+
+    // empty pointers arguements should return sane error
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,invalid), websocketpp::processor::error::invalid_arguments );
+
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(in,invalid), websocketpp::processor::error::invalid_arguments );
+
+    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,out), websocketpp::processor::error::invalid_arguments );
+
+    // test valid opcodes
+    // control opcodes should return an error, data ones shouldn't
+    for (int i = 0; i < 0xF; i++) {
+        in->set_opcode(websocketpp::frame::opcode::value(i));
+
+        env.ec = env.p.prepare_data_frame(in,out);
+
+        if (websocketpp::frame::opcode::is_control(in->get_opcode())) {
+            BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode );
+        } else {
+            BOOST_CHECK_NE( env.ec, websocketpp::processor::error::invalid_opcode );
+        }
+    }
+
+
+    //in.set_payload("foo");
+
+    //e = prepare_data_frame(in,out);
+
+
+}
+
+BOOST_AUTO_TEST_CASE( single_frame_message_too_large ) {
+    processor_setup env(true);
+    
+    env.p.set_max_message_size(3);
+    
+    uint8_t frame0[10] = {0x82, 0x84, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01};
+
+    // read message that is one byte too large
+    BOOST_CHECK_EQUAL( env.p.consume(frame0,10,env.ec), 6 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::message_too_big );
+}
+
+BOOST_AUTO_TEST_CASE( multiple_frame_message_too_large ) {
+    processor_setup env(true);
+    
+    env.p.set_max_message_size(4);
+    
+    uint8_t frame0[8] = {0x02, 0x82, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01};
+    uint8_t frame1[9] = {0x80, 0x83, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01};
+
+    // read first message frame with size under the limit
+    BOOST_CHECK_EQUAL( env.p.consume(frame0,8,env.ec), 8 );
+    BOOST_CHECK( !env.ec );
+    
+    // read second message frame that puts the size over the limit
+    BOOST_CHECK_EQUAL( env.p.consume(frame1,9,env.ec), 6 );
+    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::message_too_big );
+}
+
+
+
+BOOST_AUTO_TEST_CASE( client_handshake_request ) {
+    processor_setup env(false);
+
+    websocketpp::uri_ptr u(new websocketpp::uri("ws://localhost/"));
+
+    env.p.client_handshake_request(env.req,u, std::vector<std::string>());
+
+    BOOST_CHECK_EQUAL( env.req.get_method(), "GET" );
+    BOOST_CHECK_EQUAL( env.req.get_version(), "HTTP/1.1");
+    BOOST_CHECK_EQUAL( env.req.get_uri(), "/");
+
+    BOOST_CHECK_EQUAL( env.req.get_header("Host"), "localhost");
+    BOOST_CHECK_EQUAL( env.req.get_header("Sec-WebSocket-Version"), "13");
+    BOOST_CHECK_EQUAL( env.req.get_header("Connection"), "Upgrade");
+    BOOST_CHECK_EQUAL( env.req.get_header("Upgrade"), "websocket");
+}
+
+// TODO:
+// test cases
+// - adding headers
+// - adding Upgrade header
+// - adding Connection header
+// - adding Sec-WebSocket-Version, Sec-WebSocket-Key, or Host header
+// - other Sec* headers?
+// - User Agent header?
+
+// Origin support
+// Subprotocol requests
+
+//websocketpp::uri_ptr u(new websocketpp::uri("ws://localhost/"));
+    //env.p.client_handshake_request(env.req,u);
+
+BOOST_AUTO_TEST_CASE( client_handshake_response_404 ) {
+    processor_setup env(false);
+
+    std::string res = "HTTP/1.1 404 Not Found\r\n\r\n";
+    env.res.consume(res.data(),res.size());
+
+    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::invalid_http_status );
+}
+
+BOOST_AUTO_TEST_CASE( client_handshake_response_no_upgrade ) {
+    processor_setup env(false);
+
+    std::string res = "HTTP/1.1 101 Switching Protocols\r\n\r\n";
+    env.res.consume(res.data(),res.size());
+
+    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( client_handshake_response_no_connection ) {
+    processor_setup env(false);
+
+    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\n\r\n";
+    env.res.consume(res.data(),res.size());
+
+    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( client_handshake_response_no_accept ) {
+    processor_setup env(false);
+
+    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\nConnection: bar, UpGrAdE\r\n\r\n";
+    env.res.consume(res.data(),res.size());
+
+    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
+}
+
+BOOST_AUTO_TEST_CASE( client_handshake_response ) {
+    processor_setup env(false);
+
+    env.req.append_header("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
+
+    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\nConnection: bar, UpGrAdE\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n";
+    env.res.consume(res.data(),res.size());
+
+    BOOST_CHECK( !env.p.validate_server_handshake_response(env.req,env.res) );
+}
+
+BOOST_AUTO_TEST_CASE( extensions_disabled ) {
+    processor_setup env(true);
+
+    env.req.replace_header("Sec-WebSocket-Extensions","");
+
+    std::pair<websocketpp::lib::error_code,std::string> neg_results;
+    neg_results = env.p.negotiate_extensions(env.req);
+
+    BOOST_CHECK_EQUAL( neg_results.first, websocketpp::processor::error::extensions_disabled );
+    BOOST_CHECK_EQUAL( neg_results.second, "" );
+}
+
+BOOST_AUTO_TEST_CASE( extension_negotiation_blank ) {
+    processor_setup_ext env(true);
+
+    env.req.replace_header("Sec-WebSocket-Extensions","");
+
+    std::pair<websocketpp::lib::error_code,std::string> neg_results;
+    neg_results = env.p.negotiate_extensions(env.req);
+
+    BOOST_CHECK( !neg_results.first );
+    BOOST_CHECK_EQUAL( neg_results.second, "" );
+}
+
+BOOST_AUTO_TEST_CASE( extension_negotiation_unknown ) {
+    processor_setup_ext env(true);
+
+    env.req.replace_header("Sec-WebSocket-Extensions","foo");
+
+    std::pair<websocketpp::lib::error_code,std::string> neg_results;
+    neg_results = env.p.negotiate_extensions(env.req);
+
+    BOOST_CHECK( !neg_results.first );
+    BOOST_CHECK_EQUAL( neg_results.second, "" );
+}
+
+BOOST_AUTO_TEST_CASE( extract_subprotocols_empty ) {
+    processor_setup env(true);
+    std::vector<std::string> subps;
+
+    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
+    BOOST_CHECK_EQUAL( subps.size(), 0 );
+}
+
+BOOST_AUTO_TEST_CASE( extract_subprotocols_one ) {
+    processor_setup env(true);
+    std::vector<std::string> subps;
+
+    env.req.replace_header("Sec-WebSocket-Protocol","foo");
+
+    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
+    BOOST_REQUIRE_EQUAL( subps.size(), 1 );
+    BOOST_CHECK_EQUAL( subps[0], "foo" );
+}
+
+BOOST_AUTO_TEST_CASE( extract_subprotocols_multiple ) {
+    processor_setup env(true);
+    std::vector<std::string> subps;
+
+    env.req.replace_header("Sec-WebSocket-Protocol","foo,bar");
+
+    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
+    BOOST_REQUIRE_EQUAL( subps.size(), 2 );
+    BOOST_CHECK_EQUAL( subps[0], "foo" );
+    BOOST_CHECK_EQUAL( subps[1], "bar" );
+}
+
+BOOST_AUTO_TEST_CASE( extract_subprotocols_invalid) {
+    processor_setup env(true);
+    std::vector<std::string> subps;
+
+    env.req.replace_header("Sec-WebSocket-Protocol","foo,bar,,,,");
+
+    BOOST_CHECK_EQUAL( env.p.extract_subprotocols(env.req,subps), websocketpp::processor::error::make_error_code(websocketpp::processor::error::subprotocol_parse_error) );
+    BOOST_CHECK_EQUAL( subps.size(), 0 );
+}
+
+BOOST_AUTO_TEST_CASE( extension_negotiation_permessage_deflate ) {
+    processor_setup_ext env(true);
+
+    env.req.replace_header("Sec-WebSocket-Extensions",
+        "permessage-deflate; c2s_max_window_bits");
+
+    std::pair<websocketpp::lib::error_code,std::string> neg_results;
+    neg_results = env.p.negotiate_extensions(env.req);
+
+    BOOST_CHECK( !neg_results.first );
+    BOOST_CHECK_EQUAL( neg_results.second, "permessage-deflate" );
+}
+

test/processors/processor.cpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE processors
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/processors/processor.hpp>
+#include <websocketpp/http/request.hpp>
+
+BOOST_AUTO_TEST_CASE( exact_match ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( non_match ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(!websocketpp::processor::is_websocket_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( ci_exact_match ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: UpGrAde\r\nUpgrade: WebSocket\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( non_exact_match1 ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade,foo\r\nUpgrade: websocket,foo\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( non_exact_match2 ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: keep-alive,Upgrade,foo\r\nUpgrade: foo,websocket,bar\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
+}
+
+BOOST_AUTO_TEST_CASE( version_blank ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 0);
+}
+
+BOOST_AUTO_TEST_CASE( version_7 ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 7);
+}
+
+BOOST_AUTO_TEST_CASE( version_8 ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 8);
+}
+
+BOOST_AUTO_TEST_CASE( version_13 ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 13);
+}
+
+BOOST_AUTO_TEST_CASE( version_non_numeric ) {
+    websocketpp::http::parser::request r;
+
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: abc\r\n\r\n";
+
+    r.consume(handshake.c_str(),handshake.size());
+
+    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == -1);
+}

test/random/SConscript

@@ -0,0 +1,27 @@
+## random number generation unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','random','system'],env) + [platform_libs]
+
+objs = env.Object('random_none_boost.o', ["none.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('random_device_boost.o', ["random_device.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_random_none_boost', ["random_none_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_random_device_boost', ["random_device_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('random_none_stl.o', ["none.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('random_device_stl.o', ["random_device.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_random_none_stl', ["random_none_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_random_device_stl', ["random_device_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/random/none.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE random_none
+#include <boost/test/unit_test.hpp>
+
+#include <websocketpp/common/stdint.hpp>
+#include <websocketpp/random/none.hpp>
+
+BOOST_AUTO_TEST_CASE( does_it_compile ) {
+    websocketpp::random::none::int_generator<int32_t> rng;
+
+    int32_t foo = rng();
+
+    BOOST_CHECK( foo == 0 );
+}

test/random/random_device.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE random_device
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#include <websocketpp/common/stdint.hpp>
+#include <websocketpp/random/random_device.hpp>
+#include <websocketpp/concurrency/none.hpp>
+
+BOOST_AUTO_TEST_CASE( compiles ) {
+    websocketpp::random::random_device::int_generator<int32_t,websocketpp::concurrency::none> rng;
+
+    bool e = false;
+
+    try {
+        int32_t foo = rng();
+        std::cout << foo << std::endl;
+    } catch (...) {
+        e = true;
+    }
+
+    BOOST_CHECK( e == false );
+}

test/roles/SConscript

@@ -0,0 +1,27 @@
+## role unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system','random'],env) + [platform_libs]
+
+objs = env.Object('client_boost.o', ["client.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('server_boost.o', ["server.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_client_boost', ["client_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_server_boost', ["server_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('client_stl.o', ["client.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('server_stl.o', ["server.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_client_stl', ["client_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_server_stl', ["server_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/roles/client.cpp

@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE client
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#include <websocketpp/random/random_device.hpp>
+
+#include <websocketpp/config/core.hpp>
+#include <websocketpp/client.hpp>
+
+#include <websocketpp/http/request.hpp>
+
+struct stub_config : public websocketpp::config::core {
+    typedef core::concurrency_type concurrency_type;
+
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+
+    //typedef core::rng_type rng_type;
+    typedef websocketpp::random::random_device::int_generator<uint32_t,concurrency_type> rng_type;
+
+    typedef core::transport_type transport_type;
+
+    typedef core::endpoint_base endpoint_base;
+
+    static const websocketpp::log::level elog_level = websocketpp::log::elevel::none;
+    static const websocketpp::log::level alog_level = websocketpp::log::alevel::none;
+};
+
+typedef websocketpp::client<stub_config> client;
+typedef client::connection_ptr connection_ptr;
+
+BOOST_AUTO_TEST_CASE( invalid_uri ) {
+    client c;
+    websocketpp::lib::error_code ec;
+
+    connection_ptr con = c.get_connection("foo", ec);
+
+    BOOST_CHECK_EQUAL( ec , websocketpp::error::make_error_code(websocketpp::error::invalid_uri) );
+}
+
+BOOST_AUTO_TEST_CASE( unsecure_endpoint ) {
+    client c;
+    websocketpp::lib::error_code ec;
+
+    connection_ptr con = c.get_connection("wss://localhost/", ec);
+
+    BOOST_CHECK_EQUAL( ec , websocketpp::error::make_error_code(websocketpp::error::endpoint_not_secure) );
+}
+
+BOOST_AUTO_TEST_CASE( get_connection ) {
+    client c;
+    websocketpp::lib::error_code ec;
+
+    connection_ptr con = c.get_connection("ws://localhost/", ec);
+
+    BOOST_CHECK( con );
+    BOOST_CHECK_EQUAL( con->get_host() , "localhost" );
+    BOOST_CHECK_EQUAL( con->get_port() , 80 );
+    BOOST_CHECK_EQUAL( con->get_secure() , false );
+    BOOST_CHECK_EQUAL( con->get_resource() , "/" );
+}
+
+BOOST_AUTO_TEST_CASE( connect_con ) {
+    client c;
+    websocketpp::lib::error_code ec;
+    std::stringstream out;
+    std::string o;
+
+    c.register_ostream(&out);
+
+    connection_ptr con = c.get_connection("ws://localhost/", ec);
+    c.connect(con);
+
+    o = out.str();
+    websocketpp::http::parser::request r;
+    r.consume(o.data(),o.size());
+
+    BOOST_CHECK( r.ready() );
+    BOOST_CHECK_EQUAL( r.get_method(), "GET");
+    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1");
+    BOOST_CHECK_EQUAL( r.get_uri(), "/");
+
+    BOOST_CHECK_EQUAL( r.get_header("Host"), "localhost");
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Version"), "13");
+    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade");
+    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket");
+
+    // Key is randomly generated & User-Agent will change so just check that
+    // they are not empty.
+    BOOST_CHECK_NE( r.get_header("Sec-WebSocket-Key"), "");
+    BOOST_CHECK_NE( r.get_header("User-Agent"), "" );
+
+    // connection should have written out an opening handshake request and be in
+    // the read response internal state
+
+    // TODO: more tests related to reading the HTTP response
+    std::stringstream channel2;
+    channel2 << "e\r\n\r\n";
+    channel2 >> *con;
+}
+
+BOOST_AUTO_TEST_CASE( select_subprotocol ) {
+    client c;
+    websocketpp::lib::error_code ec;
+    using websocketpp::error::make_error_code;
+
+    connection_ptr con = c.get_connection("ws://localhost/", ec);
+
+    BOOST_CHECK( con );
+
+    con->select_subprotocol("foo",ec);
+    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::server_only) );
+    BOOST_CHECK_THROW( con->select_subprotocol("foo") , websocketpp::exception );
+}
+
+BOOST_AUTO_TEST_CASE( add_subprotocols_invalid ) {
+    client c;
+    websocketpp::lib::error_code ec;
+    using websocketpp::error::make_error_code;
+
+    connection_ptr con = c.get_connection("ws://localhost/", ec);
+    BOOST_CHECK( con );
+
+    con->add_subprotocol("",ec);
+    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::invalid_subprotocol) );
+    BOOST_CHECK_THROW( con->add_subprotocol("") , websocketpp::exception );
+
+    con->add_subprotocol("foo,bar",ec);
+    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::invalid_subprotocol) );
+    BOOST_CHECK_THROW( con->add_subprotocol("foo,bar") , websocketpp::exception );
+}
+
+BOOST_AUTO_TEST_CASE( add_subprotocols ) {
+    client c;
+    websocketpp::lib::error_code ec;
+    std::stringstream out;
+    std::string o;
+
+    c.register_ostream(&out);
+
+    connection_ptr con = c.get_connection("ws://localhost/", ec);
+    BOOST_CHECK( con );
+
+    con->add_subprotocol("foo",ec);
+    BOOST_CHECK( !ec );
+
+    BOOST_CHECK_NO_THROW( con->add_subprotocol("bar") );
+
+    c.connect(con);
+
+    o = out.str();
+    websocketpp::http::parser::request r;
+    r.consume(o.data(),o.size());
+
+    BOOST_CHECK( r.ready() );
+    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "foo, bar");
+}
+
+

test/roles/server.cpp

@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE server
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+// Test Environment:
+// server, no TLS, no locks, iostream based transport
+#include <websocketpp/config/core.hpp>
+#include <websocketpp/server.hpp>
+
+typedef websocketpp::server<websocketpp::config::core> server;
+typedef websocketpp::config::core::message_type::ptr message_ptr;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+/*struct stub_config : public websocketpp::config::core {
+    typedef core::concurrency_type concurrency_type;
+
+    typedef core::request_type request_type;
+    typedef core::response_type response_type;
+
+    typedef core::message_type message_type;
+    typedef core::con_msg_manager_type con_msg_manager_type;
+    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef core::alog_type alog_type;
+    typedef core::elog_type elog_type;
+
+    typedef core::rng_type rng_type;
+
+    typedef core::transport_type transport_type;
+
+    typedef core::endpoint_base endpoint_base;
+};*/
+
+/* Run server and return output test rig */
+std::string run_server_test(server& s, std::string input) {
+    server::connection_ptr con;
+    std::stringstream output;
+
+    s.register_ostream(&output);
+    s.clear_access_channels(websocketpp::log::alevel::all);
+    s.clear_error_channels(websocketpp::log::elevel::all);
+
+    con = s.get_connection();
+    con->start();
+
+    std::stringstream channel;
+
+    channel << input;
+    channel >> *con;
+
+    return output.str();
+}
+
+/* handler library*/
+void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
+    s->send(hdl, msg->get_payload(), msg->get_opcode());
+}
+
+bool validate_func_subprotocol(server* s, std::string* out, std::string accept,
+    websocketpp::connection_hdl hdl)
+{
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+
+    std::stringstream o;
+
+    const std::vector<std::string> & protocols = con->get_requested_subprotocols();
+    std::vector<std::string>::const_iterator it;
+
+    for (it = protocols.begin(); it != protocols.end(); ++it) {
+        o << *it << ",";
+    }
+
+    *out = o.str();
+
+    if (accept != "") {
+        con->select_subprotocol(accept);
+    }
+
+    return true;
+}
+
+void open_func_subprotocol(server* s, std::string* out, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+
+    *out = con->get_subprotocol();
+}
+
+/* Tests */
+BOOST_AUTO_TEST_CASE( basic_websocket_request ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    server s;
+    s.set_user_agent("test");
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( invalid_websocket_version ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: a\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+    std::string output = "HTTP/1.1 400 Bad Request\r\nServer: test\r\n\r\n";
+
+    server s;
+    s.set_user_agent("test");
+    //s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( unimplemented_websocket_version ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 14\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
+
+    std::string output = "HTTP/1.1 400 Bad Request\r\nSec-WebSocket-Version: 0,7,8,13\r\nServer: test\r\n\r\n";
+
+    server s;
+    s.set_user_agent("test");
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+}
+
+BOOST_AUTO_TEST_CASE( list_subprotocol_empty ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string subprotocol;
+
+    server s;
+    s.set_user_agent("test");
+    s.set_open_handler(bind(&open_func_subprotocol,&s,&subprotocol,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+    BOOST_CHECK_EQUAL(subprotocol, "");
+}
+
+BOOST_AUTO_TEST_CASE( list_subprotocol_one ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string validate;
+    std::string open;
+
+    server s;
+    s.set_user_agent("test");
+    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"",::_1));
+    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+    BOOST_CHECK_EQUAL(validate, "foo,");
+    BOOST_CHECK_EQUAL(open, "");
+}
+
+BOOST_AUTO_TEST_CASE( accept_subprotocol_one ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: foo\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string validate;
+    std::string open;
+
+    server s;
+    s.set_user_agent("test");
+    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"foo",::_1));
+    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+    BOOST_CHECK_EQUAL(validate, "foo,");
+    BOOST_CHECK_EQUAL(open, "foo");
+}
+
+BOOST_AUTO_TEST_CASE( accept_subprotocol_invalid ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: foo\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string validate;
+    std::string open;
+
+    server s;
+    s.set_user_agent("test");
+    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"foo2",::_1));
+    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
+
+    std::string o;
+
+    BOOST_CHECK_THROW(o = run_server_test(s,input), websocketpp::exception);
+}
+
+BOOST_AUTO_TEST_CASE( accept_subprotocol_two ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo, bar\r\n\r\n";
+
+    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: bar\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
+
+    std::string validate;
+    std::string open;
+
+    server s;
+    s.set_user_agent("test");
+    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"bar",::_1));
+    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
+
+    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
+    BOOST_CHECK_EQUAL(validate, "foo,bar,");
+    BOOST_CHECK_EQUAL(open, "bar");
+}
+
+/*BOOST_AUTO_TEST_CASE( user_reject_origin ) {
+    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example2.com\r\n\r\n";
+    std::string output = "HTTP/1.1 403 Forbidden\r\nServer: test\r\n\r\n";
+
+    server s;
+    s.set_user_agent("test");
+
+    BOOST_CHECK(run_server_test(s,input) == output);
+}*/

test/transport/SConscript

@@ -0,0 +1,24 @@
+## transport integration tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system','thread','random'],env) + [platform_libs] + [tls_libs]
+
+objs = env.Object('boost_integration.o', ["integration.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_boost_integration', ["boost_integration.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   objs += env_cpp11.Object('stl_integration.o', ["integration.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_stl_integration', ["stl_integration.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/transport/asio/SConscript

@@ -0,0 +1,28 @@
+## asio transport unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+Import('tls_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system','thread'],env) + [platform_libs] + [tls_libs]
+
+objs = env.Object('base_boost.o', ["base.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('timers_boost.o', ["timers.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_base_boost', ["base_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_timers_boost', ["timers_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
+   objs += env_cpp11.Object('base_stl.o', ["base.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('timers_stl.o', ["timers.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_base_stl', ["base_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_timers_stl', ["timers_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/transport/asio/base.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_asio_base
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#include <websocketpp/transport/asio/base.hpp>
+
+BOOST_AUTO_TEST_CASE( blank_error ) {
+    websocketpp::lib::error_code ec;
+
+    BOOST_CHECK( !ec );
+}
+
+BOOST_AUTO_TEST_CASE( asio_error ) {
+    using websocketpp::transport::asio::error::make_error_code;
+    using websocketpp::transport::asio::error::general;
+
+    websocketpp::lib::error_code ec = make_error_code(general);
+
+    BOOST_CHECK( ec == general );
+    BOOST_CHECK( ec.value() == 1 );
+}

test/transport/asio/timers.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_asio_timers
+#include <boost/test/unit_test.hpp>
+
+#include <exception>
+#include <iostream>
+
+#include <websocketpp/common/thread.hpp>
+
+#include <websocketpp/transport/asio/endpoint.hpp>
+#include <websocketpp/transport/asio/security/tls.hpp>
+
+// Concurrency
+#include <websocketpp/concurrency/none.hpp>
+
+// HTTP
+#include <websocketpp/http/request.hpp>
+#include <websocketpp/http/response.hpp>
+
+// Loggers
+#include <websocketpp/logger/stub.hpp>
+//#include <websocketpp/logger/basic.hpp>
+
+#include <boost/asio.hpp>
+
+// Accept a connection, read data, and discard until EOF
+void run_dummy_server(int port) {
+    using boost::asio::ip::tcp;
+
+    try {
+        boost::asio::io_service io_service;
+        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), port));
+        tcp::socket socket(io_service);
+
+        acceptor.accept(socket);
+        for (;;) {
+            char data[512];
+            boost::system::error_code ec;
+            socket.read_some(boost::asio::buffer(data), ec);
+            if (ec == boost::asio::error::eof) {
+                break;
+            } else if (ec) {
+                // other error
+                throw ec;
+            }
+        }
+    } catch (std::exception & e) {
+        std::cout << e.what() << std::endl;
+    } catch (boost::system::error_code & ec) {
+        std::cout << ec.message() << std::endl;
+    }
+}
+
+// Wait for the specified time period then fail the test
+void run_test_timer(long value) {
+    boost::asio::io_service ios;
+    boost::asio::deadline_timer t(ios,boost::posix_time::milliseconds(value));
+    boost::system::error_code ec;
+    t.wait(ec);
+    BOOST_FAIL( "Test timed out" );
+}
+
+struct config {
+    typedef websocketpp::concurrency::none concurrency_type;
+    //typedef websocketpp::log::basic<concurrency_type,websocketpp::log::alevel> alog_type;
+    typedef websocketpp::log::stub alog_type;
+    typedef websocketpp::log::stub elog_type;
+    typedef websocketpp::http::parser::request request_type;
+    typedef websocketpp::http::parser::response response_type;
+    typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
+
+    static const bool enable_multithreading = true;
+
+    static const long timeout_socket_pre_init = 1000;
+    static const long timeout_proxy = 1000;
+    static const long timeout_socket_post_init = 1000;
+    static const long timeout_dns_resolve = 1000;
+    static const long timeout_connect = 1000;
+    static const long timeout_socket_shutdown = 1000;
+};
+
+// Mock context that does no validation
+typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
+context_ptr on_tls_init(websocketpp::connection_hdl) {
+    return context_ptr(new boost::asio::ssl::context(boost::asio::ssl::context::tlsv1));
+}
+
+// Mock connection
+struct mock_con: public websocketpp::transport::asio::connection<config> {
+    typedef websocketpp::transport::asio::connection<config> base;
+
+    mock_con(bool a, config::alog_type& b, config::elog_type& c) : base(a,b,c) {}
+
+    void start() {
+        base::init(websocketpp::lib::bind(&mock_con::handle_start,this,
+            websocketpp::lib::placeholders::_1));
+    }
+
+    void handle_start(const websocketpp::lib::error_code& ec) {
+        using websocketpp::transport::asio::socket::make_error_code;
+        using websocketpp::transport::asio::socket::error::tls_handshake_timeout;
+
+        BOOST_CHECK_EQUAL( ec, make_error_code(tls_handshake_timeout) );
+
+        base::cancel_socket();
+    }
+};
+
+typedef websocketpp::transport::asio::connection<config> con_type;
+typedef websocketpp::lib::shared_ptr<mock_con> connection_ptr;
+
+struct mock_endpoint : public websocketpp::transport::asio::endpoint<config> {
+    typedef websocketpp::transport::asio::endpoint<config> base;
+
+    mock_endpoint() {
+        alog.set_channels(websocketpp::log::alevel::all);
+        base::init_logging(&alog,&elog);
+        init_asio();
+    }
+
+    void connect(std::string u) {
+        m_con.reset(new mock_con(false,alog,elog));
+        websocketpp::uri_ptr uri(new websocketpp::uri(u));
+
+        BOOST_CHECK( uri->get_valid() );
+        BOOST_CHECK_EQUAL( base::init(m_con), websocketpp::lib::error_code() );
+
+        base::async_connect(
+            m_con,
+            uri,
+            websocketpp::lib::bind(
+                &mock_endpoint::handle_connect,
+                this,
+                m_con,
+                websocketpp::lib::placeholders::_1
+            )
+        );
+    }
+
+    void handle_connect(connection_ptr con, websocketpp::lib::error_code const & ec)
+    {
+        BOOST_CHECK( !ec );
+        con->start();
+    }
+
+    connection_ptr m_con;
+    config::alog_type alog;
+    config::elog_type elog;
+};
+
+BOOST_AUTO_TEST_CASE( tls_handshake_timeout ) {
+    websocketpp::lib::thread dummy_server(websocketpp::lib::bind(&run_dummy_server,9005));
+    websocketpp::lib::thread timer(websocketpp::lib::bind(&run_test_timer,5000));
+    dummy_server.detach();
+    timer.detach();
+
+    mock_endpoint endpoint;
+    endpoint.set_tls_init_handler(&on_tls_init);
+    endpoint.connect("wss://localhost:9005");
+    endpoint.run();
+}

test/transport/hybi_util.cpp

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE hybi_util
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#include "../../src/processors/hybi_util.hpp"
+#include "../../src/network_utilities.hpp"
+
+BOOST_AUTO_TEST_CASE( circshift_0 ) {
+    if (sizeof(size_t) == 8) {
+        size_t test = 0x0123456789abcdef;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,0);
+
+        BOOST_CHECK( test == 0x0123456789abcdef);
+    } else {
+        size_t test = 0x01234567;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,0);
+
+        BOOST_CHECK( test == 0x01234567);
+    }
+}
+
+BOOST_AUTO_TEST_CASE( circshift_1 ) {
+    if (sizeof(size_t) == 8) {
+        size_t test = 0x0123456789abcdef;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,1);
+
+        BOOST_CHECK( test == 0xef0123456789abcd);
+    } else {
+        size_t test = 0x01234567;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,1);
+
+        BOOST_CHECK( test == 0x67012345);
+    }
+}
+
+BOOST_AUTO_TEST_CASE( circshift_2 ) {
+    if (sizeof(size_t) == 8) {
+        size_t test = 0x0123456789abcdef;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,2);
+
+        BOOST_CHECK( test == 0xcdef0123456789ab);
+    } else {
+        size_t test = 0x01234567;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,2);
+
+        BOOST_CHECK( test == 0x45670123);
+    }
+}
+
+BOOST_AUTO_TEST_CASE( circshift_3 ) {
+    if (sizeof(size_t) == 8) {
+        size_t test = 0x0123456789abcdef;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,3);
+
+        BOOST_CHECK( test == 0xabcdef0123456789);
+    } else {
+        size_t test = 0x01234567;
+
+        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,3);
+
+        BOOST_CHECK( test == 0x23456701);
+    }
+}

test/transport/integration.cpp

@@ -0,0 +1,606 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_integration
+#include <boost/test/unit_test.hpp>
+
+#include <websocketpp/common/thread.hpp>
+
+#include <websocketpp/config/core.hpp>
+#include <websocketpp/config/core_client.hpp>
+#include <websocketpp/config/asio.hpp>
+#include <websocketpp/config/asio_client.hpp>
+#include <websocketpp/config/debug_asio.hpp>
+#include <websocketpp/server.hpp>
+#include <websocketpp/client.hpp>
+
+struct config : public websocketpp::config::asio_client {
+    typedef config type;
+    typedef websocketpp::config::asio base;
+
+    typedef base::concurrency_type concurrency_type;
+
+    typedef base::request_type request_type;
+    typedef base::response_type response_type;
+
+    typedef base::message_type message_type;
+    typedef base::con_msg_manager_type con_msg_manager_type;
+    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef base::alog_type alog_type;
+    typedef base::elog_type elog_type;
+
+    typedef base::rng_type rng_type;
+
+    struct transport_config : public base::transport_config {
+        typedef type::concurrency_type concurrency_type;
+        typedef type::alog_type alog_type;
+        typedef type::elog_type elog_type;
+        typedef type::request_type request_type;
+        typedef type::response_type response_type;
+        typedef websocketpp::transport::asio::basic_socket::endpoint
+            socket_type;
+    };
+
+    typedef websocketpp::transport::asio::endpoint<transport_config>
+        transport_type;
+
+    //static const websocketpp::log::level elog_level = websocketpp::log::elevel::all;
+    //static const websocketpp::log::level alog_level = websocketpp::log::alevel::all;
+
+    /// Length of time before an opening handshake is aborted
+    static const long timeout_open_handshake = 500;
+    /// Length of time before a closing handshake is aborted
+    static const long timeout_close_handshake = 500;
+    /// Length of time to wait for a pong after a ping
+    static const long timeout_pong = 500;
+};
+
+struct config_tls : public websocketpp::config::asio_tls_client {
+    typedef config type;
+    typedef websocketpp::config::asio base;
+
+    typedef base::concurrency_type concurrency_type;
+
+    typedef base::request_type request_type;
+    typedef base::response_type response_type;
+
+    typedef base::message_type message_type;
+    typedef base::con_msg_manager_type con_msg_manager_type;
+    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
+
+    typedef base::alog_type alog_type;
+    typedef base::elog_type elog_type;
+
+    typedef base::rng_type rng_type;
+
+    struct transport_config : public base::transport_config {
+        typedef type::concurrency_type concurrency_type;
+        typedef type::alog_type alog_type;
+        typedef type::elog_type elog_type;
+        typedef type::request_type request_type;
+        typedef type::response_type response_type;
+        typedef websocketpp::transport::asio::basic_socket::endpoint
+            socket_type;
+    };
+
+    typedef websocketpp::transport::asio::endpoint<transport_config>
+        transport_type;
+
+    //static const websocketpp::log::level elog_level = websocketpp::log::elevel::all;
+    //static const websocketpp::log::level alog_level = websocketpp::log::alevel::all;
+
+    /// Length of time before an opening handshake is aborted
+    static const long timeout_open_handshake = 500;
+    /// Length of time before a closing handshake is aborted
+    static const long timeout_close_handshake = 500;
+    /// Length of time to wait for a pong after a ping
+    static const long timeout_pong = 500;
+};
+
+typedef websocketpp::server<config> server;
+typedef websocketpp::client<config> client;
+
+typedef websocketpp::server<config_tls> server_tls;
+typedef websocketpp::client<config_tls> client_tls;
+
+typedef websocketpp::server<websocketpp::config::core> iostream_server;
+typedef websocketpp::client<websocketpp::config::core_client> iostream_client;
+
+using websocketpp::lib::placeholders::_1;
+using websocketpp::lib::placeholders::_2;
+using websocketpp::lib::bind;
+
+template <typename T>
+void close_after_timeout(T & e, websocketpp::connection_hdl hdl, long timeout) {
+    sleep(timeout);
+
+    websocketpp::lib::error_code ec;
+    e.close(hdl,websocketpp::close::status::normal,"",ec);
+    BOOST_CHECK(!ec);
+}
+
+void run_server(server * s, int port, bool log = false) {
+    if (log) {
+        s->set_access_channels(websocketpp::log::alevel::all);
+        s->set_error_channels(websocketpp::log::elevel::all);
+    } else {
+        s->clear_access_channels(websocketpp::log::alevel::all);
+        s->clear_error_channels(websocketpp::log::elevel::all);
+    }
+
+    s->init_asio();
+    s->set_reuse_addr(true);
+
+    s->listen(port);
+    s->start_accept();
+    s->run();
+}
+
+void run_client(client & c, std::string uri, bool log = false) {
+    if (log) {
+        c.set_access_channels(websocketpp::log::alevel::all);
+        c.set_error_channels(websocketpp::log::elevel::all);
+    } else {
+        c.clear_access_channels(websocketpp::log::alevel::all);
+        c.clear_error_channels(websocketpp::log::elevel::all);
+    }
+    websocketpp::lib::error_code ec;
+    c.init_asio(ec);
+    c.set_reuse_addr(true);
+    BOOST_CHECK(!ec);
+
+    client::connection_ptr con = c.get_connection(uri,ec);
+    BOOST_CHECK( !ec );
+    c.connect(con);
+
+    c.run();
+}
+
+void run_client_and_mark(client * c, bool * flag, websocketpp::lib::mutex * mutex) {
+    c->run();
+    BOOST_CHECK( true );
+    websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(*mutex);
+    *flag = true;
+    BOOST_CHECK( true );
+}
+
+void run_time_limited_client(client & c, std::string uri, long timeout,
+    bool log)
+{
+    if (log) {
+        c.set_access_channels(websocketpp::log::alevel::all);
+        c.set_error_channels(websocketpp::log::elevel::all);
+    } else {
+        c.clear_access_channels(websocketpp::log::alevel::all);
+        c.clear_error_channels(websocketpp::log::elevel::all);
+    }
+    c.init_asio();
+
+    websocketpp::lib::error_code ec;
+    client::connection_ptr con = c.get_connection(uri,ec);
+    BOOST_CHECK( !ec );
+    c.connect(con);
+
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(
+        &close_after_timeout<client>,
+        websocketpp::lib::ref(c),
+        con->get_handle(),
+        timeout
+    ));
+    tthread.detach();
+
+    c.run();
+}
+
+void run_dummy_server(int port) {
+    using boost::asio::ip::tcp;
+
+    try {
+        boost::asio::io_service io_service;
+        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), port));
+        tcp::socket socket(io_service);
+
+        acceptor.accept(socket);
+        for (;;) {
+            char data[512];
+            boost::system::error_code ec;
+            socket.read_some(boost::asio::buffer(data), ec);
+            if (ec == boost::asio::error::eof) {
+                break;
+            } else if (ec) {
+                // other error
+                throw ec;
+            }
+        }
+    } catch (std::exception & e) {
+        std::cout << e.what() << std::endl;
+    } catch (boost::system::error_code & ec) {
+        std::cout << ec.message() << std::endl;
+    }
+}
+
+void run_dummy_client(std::string port) {
+    using boost::asio::ip::tcp;
+
+    try {
+        boost::asio::io_service io_service;
+        tcp::resolver resolver(io_service);
+        tcp::resolver::query query("localhost", port);
+        tcp::resolver::iterator iterator = resolver.resolve(query);
+        tcp::socket socket(io_service);
+
+        boost::asio::connect(socket, iterator);
+        for (;;) {
+            char data[512];
+            boost::system::error_code ec;
+            socket.read_some(boost::asio::buffer(data), ec);
+            if (ec == boost::asio::error::eof) {
+                break;
+            } else if (ec) {
+                // other error
+                throw ec;
+            }
+        }
+    } catch (std::exception & e) {
+        std::cout << e.what() << std::endl;
+    } catch (boost::system::error_code & ec) {
+        std::cout << ec.message() << std::endl;
+    }
+}
+
+bool on_ping(websocketpp::connection_hdl, std::string) {
+    return false;
+}
+
+void cancel_on_open(server * s, websocketpp::connection_hdl) {
+    s->stop_listening();
+}
+
+void stop_on_close(server * s, websocketpp::connection_hdl hdl) {
+    server::connection_ptr con = s->get_con_from_hdl(hdl);
+    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
+    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
+    s->stop();
+}
+
+template <typename T>
+void ping_on_open(T * c, std::string payload, websocketpp::connection_hdl hdl) {
+    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
+    con->ping(payload);
+}
+
+void fail_on_pong(websocketpp::connection_hdl, std::string) {
+    BOOST_FAIL( "expected no pong handler" );
+}
+
+void fail_on_pong_timeout(websocketpp::connection_hdl, std::string) {
+    BOOST_FAIL( "expected no pong timeout" );
+}
+
+void req_pong(std::string expected_payload, websocketpp::connection_hdl,
+    std::string payload)
+{
+    BOOST_CHECK_EQUAL( expected_payload, payload );
+}
+
+void fail_on_open(websocketpp::connection_hdl) {
+    BOOST_FAIL( "expected no open handler" );
+}
+
+void delay(websocketpp::connection_hdl, long duration) {
+    sleep(duration);
+}
+
+template <typename T>
+void check_ec(T * c, websocketpp::lib::error_code ec,
+    websocketpp::connection_hdl hdl)
+{
+    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
+    BOOST_CHECK_EQUAL( con->get_ec(), ec );
+    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
+    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
+}
+
+template <typename T>
+void check_ec_and_stop(T * e, websocketpp::lib::error_code ec,
+    websocketpp::connection_hdl hdl)
+{
+    typename T::connection_ptr con = e->get_con_from_hdl(hdl);
+    BOOST_CHECK_EQUAL( con->get_ec(), ec );
+    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
+    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
+    e->stop();
+}
+
+template <typename T>
+void req_pong_timeout(T * c, std::string expected_payload,
+    websocketpp::connection_hdl hdl, std::string payload)
+{
+    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
+    BOOST_CHECK_EQUAL( payload, expected_payload );
+    con->close(websocketpp::close::status::normal,"");
+}
+
+template <typename T>
+void close(T * e, websocketpp::connection_hdl hdl) {
+    e->get_con_from_hdl(hdl)->close(websocketpp::close::status::normal,"");
+}
+
+// Wait for the specified time period then fail the test
+void run_test_timer(long value) {
+    sleep(value);
+    BOOST_FAIL( "Test timed out" );
+}
+
+BOOST_AUTO_TEST_CASE( pong_no_timeout ) {
+    server s;
+    client c;
+
+    s.set_close_handler(bind(&stop_on_close,&s,::_1));
+
+    // send a ping when the connection is open
+    c.set_open_handler(bind(&ping_on_open<client>,&c,"foo",::_1));
+    // require that a pong with matching payload is received
+    c.set_pong_handler(bind(&req_pong,"foo",::_1,::_2));
+    // require that a pong timeout is NOT received
+    c.set_pong_timeout_handler(bind(&fail_on_pong_timeout,::_1,::_2));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+
+    // Run a client that closes the connection after 1 seconds
+    run_time_limited_client(c, "http://localhost:9005", 1, false);
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( pong_timeout ) {
+    server s;
+    client c;
+
+    s.set_ping_handler(on_ping);
+    s.set_close_handler(bind(&stop_on_close,&s,::_1));
+
+    c.set_fail_handler(bind(&check_ec<client>,&c,
+        websocketpp::lib::error_code(),::_1));
+
+    c.set_pong_handler(bind(&fail_on_pong,::_1,::_2));
+    c.set_open_handler(bind(&ping_on_open<client>,&c,"foo",::_1));
+    c.set_pong_timeout_handler(bind(&req_pong_timeout<client>,&c,"foo",::_1,::_2));
+    c.set_close_handler(bind(&check_ec<client>,&c,
+        websocketpp::lib::error_code(),::_1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,6));
+    tthread.detach();
+
+    run_client(c, "http://localhost:9005",false);
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( client_open_handshake_timeout ) {
+    client c;
+
+    // set open handler to fail test
+    c.set_open_handler(bind(&fail_on_open,::_1));
+    // set fail hander to test for the right fail error code
+    c.set_fail_handler(bind(&check_ec<client>,&c,
+        websocketpp::error::open_handshake_timeout,::_1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_dummy_server,9005));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,6));
+    sthread.detach();
+    tthread.detach();
+
+    run_client(c, "http://localhost:9005");
+}
+
+BOOST_AUTO_TEST_CASE( server_open_handshake_timeout ) {
+    server s;
+
+    // set open handler to fail test
+    s.set_open_handler(bind(&fail_on_open,::_1));
+    // set fail hander to test for the right fail error code
+    s.set_fail_handler(bind(&check_ec_and_stop<server>,&s,
+        websocketpp::error::open_handshake_timeout,::_1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,6));
+    tthread.detach();
+
+    run_dummy_client("9005");
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( client_self_initiated_close_handshake_timeout ) {
+    server s;
+    client c;
+
+    // on open server sleeps for longer than the timeout
+    // on open client sends close handshake
+    // client handshake timer should be triggered
+    s.set_open_handler(bind(&delay,::_1,1));
+    s.set_close_handler(bind(&stop_on_close,&s,::_1));
+
+    c.set_open_handler(bind(&close<client>,&c,::_1));
+    c.set_close_handler(bind(&check_ec<client>,&c,
+        websocketpp::error::close_handshake_timeout,::_1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,6));
+    tthread.detach();
+
+    run_client(c, "http://localhost:9005", false);
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( client_peer_initiated_close_handshake_timeout ) {
+    // on open server sends close
+    // client should ack normally and then wait
+    // server leaves TCP connection open
+    // client handshake timer should be triggered
+
+    // TODO: how to make a mock server that leaves the TCP connection open?
+}
+
+BOOST_AUTO_TEST_CASE( server_self_initiated_close_handshake_timeout ) {
+    server s;
+    client c;
+
+    // on open server sends close
+    // on open client sleeps for longer than the timeout
+    // server handshake timer should be triggered
+
+    s.set_open_handler(bind(&close<server>,&s,::_1));
+    s.set_close_handler(bind(&check_ec_and_stop<server>,&s,
+        websocketpp::error::close_handshake_timeout,::_1));
+
+    c.set_open_handler(bind(&delay,::_1,1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,6));
+    tthread.detach();
+
+    run_client(c, "http://localhost:9005",false);
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( client_runs_out_of_work ) {
+    client c;
+
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,3));
+    tthread.detach();
+
+    websocketpp::lib::error_code ec;
+    c.init_asio(ec);
+    BOOST_CHECK(!ec);
+
+    c.run();
+
+    // This test checks that an io_service with no work ends immediately.
+    BOOST_CHECK(true);
+}
+
+
+
+
+BOOST_AUTO_TEST_CASE( client_is_perpetual ) {
+    client c;
+    bool flag = false;
+    websocketpp::lib::mutex mutex;
+
+    websocketpp::lib::error_code ec;
+    c.init_asio(ec);
+    BOOST_CHECK(!ec);
+
+    c.start_perpetual();
+
+    websocketpp::lib::thread cthread(websocketpp::lib::bind(&run_client_and_mark,&c,&flag,&mutex));
+
+    sleep(1);
+
+    {
+        // Checks that the thread hasn't exited yet
+        websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(mutex);
+        BOOST_CHECK( !flag );
+    }
+
+    c.stop_perpetual();
+
+    sleep(1);
+
+    {
+        // Checks that the thread has exited
+        websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(mutex);
+        BOOST_CHECK( flag );
+    }
+
+    cthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( client_failed_connection ) {
+    client c;
+
+    run_time_limited_client(c,"http://localhost:9005", 5, false);
+}
+
+BOOST_AUTO_TEST_CASE( stop_listening ) {
+    server s;
+    client c;
+
+    // the first connection stops the server from listening
+    s.set_open_handler(bind(&cancel_on_open,&s,::_1));
+
+    // client immediately closes after opening a connection
+    c.set_open_handler(bind(&close<client>,&c,::_1));
+
+    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
+    websocketpp::lib::thread tthread(websocketpp::lib::bind(&run_test_timer,2));
+    tthread.detach();
+
+    run_client(c, "http://localhost:9005",false);
+
+    sthread.join();
+}
+
+BOOST_AUTO_TEST_CASE( pause_reading ) {
+    iostream_server s;
+    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+    char buffer[2] = { char(0x81), char(0x80) };
+    
+    // suppress output (it needs a place to go to avoid error but we don't care what it is)
+    std::stringstream null_output;
+    s.register_ostream(&null_output);
+    
+    iostream_server::connection_ptr con = s.get_connection();
+    con->start();
+
+    // read handshake, should work
+    BOOST_CHECK_EQUAL( con->read_some(handshake.data(), handshake.length()), handshake.length());
+    
+    // pause reading and try again. The first read should work, the second should return 0
+    // the first read was queued already after the handshake so it will go through because
+    // reading wasn't paused when it was queued. The byte it reads wont be enough to
+    // complete the frame so another read will be requested. This one wont actually happen
+    // because the connection is paused now.
+    con->pause_reading();
+    BOOST_CHECK_EQUAL( con->read_some(buffer, 1), 1);
+    BOOST_CHECK_EQUAL( con->read_some(buffer+1, 1), 0);
+    // resume reading and try again. Should work this time because the resume should have
+    // re-queued a read.
+    con->resume_reading();
+    BOOST_CHECK_EQUAL( con->read_some(buffer+1, 1), 1);
+}
+
+
+BOOST_AUTO_TEST_CASE( server_connection_cleanup ) {
+    server_tls s;
+}

test/transport/iostream/SConscript

@@ -0,0 +1,31 @@
+## iostream transport unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
+
+objs = env.Object('iostream_base_boost.o', ["base.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('iostream_connection_boost.o', ["connection.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('iostream_endpoint_boost.o', ["endpoint.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_iostream_base_boost', ["iostream_base_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_iostream_connection_boost', ["iostream_connection_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_iostream_endpoint_boost', ["iostream_endpoint_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('iostream_base_stl.o', ["base.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('iostream_connection_stl.o', ["connection.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('iostream_endpoint_stl.o', ["endpoint.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_iostream_base_stl', ["iostream_base_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_iostream_connection_stl', ["iostream_connection_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_iostream_endpoint_stl', ["iostream_endpoint_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/transport/iostream/base.cpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_iostream_base
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+BOOST_AUTO_TEST_CASE( placeholder ) {}

test/transport/iostream/connection.cpp

@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_iostream_connection
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <cstring>
+#include <string>
+
+#include <websocketpp/common/memory.hpp>
+
+#include <websocketpp/error.hpp>
+#include <websocketpp/transport/iostream/connection.hpp>
+
+// Policies
+#include <websocketpp/concurrency/basic.hpp>
+#include <websocketpp/logger/basic.hpp>
+
+struct config {
+    typedef websocketpp::concurrency::basic concurrency_type;
+    typedef websocketpp::log::basic<concurrency_type,
+        websocketpp::log::elevel> elog_type;
+    typedef websocketpp::log::basic<concurrency_type,
+        websocketpp::log::alevel> alog_type;
+};
+
+typedef websocketpp::transport::iostream::connection<config> iostream_con;
+
+using websocketpp::transport::iostream::error::make_error_code;
+
+struct stub_con : public iostream_con {
+    typedef stub_con type;
+    typedef websocketpp::lib::shared_ptr<type> ptr;
+    typedef iostream_con::timer_ptr timer_ptr;
+
+    stub_con(bool is_server, config::alog_type & a, config::elog_type & e)
+        : iostream_con(is_server,a,e)
+        // Set the error to a known code that is unused by the library
+        // This way we can easily confirm that the handler was run at all.
+        , ec(websocketpp::error::make_error_code(websocketpp::error::test))
+        , indef_read_total(0)
+    {}
+
+    /// Get a shared pointer to this component
+    ptr get_shared() {
+        return websocketpp::lib::static_pointer_cast<type>(iostream_con::get_shared());
+    }
+
+    void write(std::string msg) {
+        iostream_con::async_write(
+            msg.data(),
+            msg.size(),
+            websocketpp::lib::bind(
+                &stub_con::handle_op,
+                type::get_shared(),
+                websocketpp::lib::placeholders::_1
+            )
+        );
+    }
+
+    void write(std::vector<websocketpp::transport::buffer> & bufs) {
+        iostream_con::async_write(
+            bufs,
+            websocketpp::lib::bind(
+                &stub_con::handle_op,
+                type::get_shared(),
+                websocketpp::lib::placeholders::_1
+            )
+        );
+    }
+
+    void async_read_at_least(size_t num_bytes, char *buf, size_t len)
+    {
+        iostream_con::async_read_at_least(
+            num_bytes,
+            buf,
+            len,
+            websocketpp::lib::bind(
+                &stub_con::handle_op,
+                type::get_shared(),
+                websocketpp::lib::placeholders::_1
+            )
+        );
+    }
+
+    void handle_op(websocketpp::lib::error_code const & e) {
+        ec = e;
+    }
+
+    void async_read_indef(size_t num_bytes, char *buf, size_t len)
+    {
+        indef_read_size = num_bytes;
+        indef_read_buf = buf;
+        indef_read_len = len;
+        
+        indef_read();
+    }
+
+    void indef_read() {
+        iostream_con::async_read_at_least(
+            indef_read_size,
+            indef_read_buf,
+            indef_read_len,
+            websocketpp::lib::bind(
+                &stub_con::handle_indef,
+                type::get_shared(),
+                websocketpp::lib::placeholders::_1,
+                websocketpp::lib::placeholders::_2
+            )
+        );
+    }
+
+    void handle_indef(websocketpp::lib::error_code const & e, size_t amt_read) {
+        ec = e;
+        indef_read_total += amt_read;
+        
+        indef_read();
+    }
+
+    websocketpp::lib::error_code ec;
+    size_t indef_read_size;
+    char * indef_read_buf;
+    size_t indef_read_len;
+    size_t indef_read_total;
+};
+
+// Stubs
+config::alog_type alogger;
+config::elog_type elogger;
+
+BOOST_AUTO_TEST_CASE( const_methods ) {
+    iostream_con::ptr con(new iostream_con(true,alogger,elogger));
+
+    BOOST_CHECK( con->is_secure() == false );
+    BOOST_CHECK( con->get_remote_endpoint() == "iostream transport" );
+}
+
+BOOST_AUTO_TEST_CASE( write_before_ostream_set ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    con->write("foo");
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::transport::iostream::error::output_stream_required) );
+
+    std::vector<websocketpp::transport::buffer> bufs;
+    con->write(bufs);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::transport::iostream::error::output_stream_required) );
+}
+
+BOOST_AUTO_TEST_CASE( async_write ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    std::stringstream output;
+
+    con->register_ostream(&output);
+
+    con->write("foo");
+
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( output.str() == "foo" );
+}
+
+BOOST_AUTO_TEST_CASE( async_write_vector_0 ) {
+    std::stringstream output;
+
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+    con->register_ostream(&output);
+
+    std::vector<websocketpp::transport::buffer> bufs;
+
+    con->write(bufs);
+
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( output.str() == "" );
+}
+
+BOOST_AUTO_TEST_CASE( async_write_vector_1 ) {
+    std::stringstream output;
+
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+    con->register_ostream(&output);
+
+    std::vector<websocketpp::transport::buffer> bufs;
+
+    std::string foo = "foo";
+
+    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
+
+    con->write(bufs);
+
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( output.str() == "foo" );
+}
+
+BOOST_AUTO_TEST_CASE( async_write_vector_2 ) {
+    std::stringstream output;
+
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+    con->register_ostream(&output);
+
+    std::vector<websocketpp::transport::buffer> bufs;
+
+    std::string foo = "foo";
+    std::string bar = "bar";
+
+    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
+    bufs.push_back(websocketpp::transport::buffer(bar.data(),bar.size()));
+
+    con->write(bufs);
+
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( output.str() == "foobar" );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_too_much ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[10];
+
+    con->async_read_at_least(11,buf,10);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::transport::iostream::error::invalid_num_bytes) );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_double_read ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[10];
+
+    con->async_read_at_least(5,buf,10);
+    con->async_read_at_least(5,buf,10);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::transport::iostream::error::double_read) );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[10];
+
+    memset(buf,'x',10);
+
+    con->async_read_at_least(5,buf,10);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    std::stringstream channel;
+    channel << "abcd";
+    channel >> *con;
+    BOOST_CHECK( channel.tellg() == -1 );
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    std::stringstream channel2;
+    channel2 << "e";
+    channel2 >> *con;
+    BOOST_CHECK( channel2.tellg() == -1 );
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( std::string(buf,10) == "abcdexxxxx" );
+
+    std::stringstream channel3;
+    channel3 << "f";
+    channel3 >> *con;
+    BOOST_CHECK( channel3.tellg() == 0 );
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( std::string(buf,10) == "abcdexxxxx" );
+    con->async_read_at_least(1,buf+5,5);
+    channel3 >> *con;
+    BOOST_CHECK( channel3.tellg() == -1 );
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( std::string(buf,10) == "abcdefxxxx" );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least2 ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[10];
+
+    memset(buf,'x',10);
+
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    std::stringstream channel;
+    channel << "abcdefg";
+    channel >> *con;
+    BOOST_CHECK( channel.tellg() == 5 );
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( std::string(buf,10) == "abcdexxxxx" );
+
+    con->async_read_at_least(1,buf+5,5);
+    channel >> *con;
+    BOOST_CHECK( channel.tellg() == -1 );
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK( std::string(buf,10) == "abcdefgxxx" );
+}
+
+void timer_callback_stub(websocketpp::lib::error_code const &) {}
+
+BOOST_AUTO_TEST_CASE( set_timer ) {
+   stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    stub_con::timer_ptr tp = con->set_timer(1000,timer_callback_stub);
+
+    BOOST_CHECK( !tp );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_read_some ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[10];
+    memset(buf,'x',10);
+
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    char input[10] = "abcdefg";
+    BOOST_CHECK_EQUAL(con->read_some(input,5), 5);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
+
+    BOOST_CHECK_EQUAL(con->read_some(input+5,2), 0);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
+
+    con->async_read_at_least(1,buf+5,5);
+    BOOST_CHECK_EQUAL(con->read_some(input+5,2), 2);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdefgxxx" );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_read_some_indef ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[20];
+    memset(buf,'x',20);
+
+    con->async_read_indef(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    // here we expect to return early from read some because the outstanding
+    // read was for 5 bytes and we were called with 10.
+    char input[11] = "aaaaabbbbb";
+    BOOST_CHECK_EQUAL(con->read_some(input,10), 5);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "aaaaaxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 5 );
+    
+    // A subsequent read should read 5 more because the indef read refreshes
+    // itself. The new read will start again at the beginning of the buffer.
+    BOOST_CHECK_EQUAL(con->read_some(input+5,5), 5);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_read_all ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[20];
+    memset(buf,'x',20);
+
+    con->async_read_indef(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    char input[11] = "aaaaabbbbb";
+    BOOST_CHECK_EQUAL(con->read_all(input,10), 10);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
+}
+
+BOOST_AUTO_TEST_CASE( eof_flag ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+    char buf[10];
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+    con->eof();
+    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::eof) );
+}
+
+BOOST_AUTO_TEST_CASE( fatal_error_flag ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+    char buf[10];
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+    con->fatal_error();
+    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::pass_through) );
+}
+
+BOOST_AUTO_TEST_CASE( shared_pointer_memory_cleanup ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    BOOST_CHECK_EQUAL(con.use_count(), 1);
+
+    char buf[10];
+    memset(buf,'x',10);
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+    BOOST_CHECK_EQUAL(con.use_count(), 2);
+
+    char input[10] = "foo";
+    con->read_some(input,3);
+    BOOST_CHECK_EQUAL(con.use_count(), 2);
+
+    con->read_some(input,2);
+    BOOST_CHECK_EQUAL( std::string(buf,10), "foofoxxxxx" );
+    BOOST_CHECK_EQUAL(con.use_count(), 1);
+
+    con->async_read_at_least(5,buf,5);
+    BOOST_CHECK_EQUAL(con.use_count(), 2);
+
+    con->eof();
+    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::eof) );
+    BOOST_CHECK_EQUAL(con.use_count(), 1);
+}
+

test/transport/iostream/endpoint.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE transport_iostream_endpoint
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+
+#include <websocketpp/transport/iostream/endpoint.hpp>
+
+BOOST_AUTO_TEST_CASE( placeholder ) {}
+
+/*BOOST_AUTO_TEST_CASE( blank_error ) {
+    websocketpp::lib::error_code ec;
+
+    BOOST_CHECK( !ec );
+}*/

test/utility/SConscript

@@ -0,0 +1,36 @@
+## utility unit tests
+##
+
+Import('env')
+Import('env_cpp11')
+Import('boostlibs')
+Import('platform_libs')
+Import('polyfill_libs')
+
+env = env.Clone ()
+env_cpp11 = env_cpp11.Clone ()
+
+BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
+
+objs = env.Object('uri_boost.o', ["uri.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('utilities_boost.o', ["utilities.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('close_boost.o', ["close.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('sha1_boost.o', ["sha1.cpp"], LIBS = BOOST_LIBS)
+prgs = env.Program('test_uri_boost', ["uri_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_utility_boost', ["utilities_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_frame', ["frame.cpp"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_close_boost', ["close_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_sha1_boost', ["sha1_boost.o"], LIBS = BOOST_LIBS)
+
+if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
+   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
+   objs += env_cpp11.Object('utilities_stl.o', ["utilities.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('uri_stl.o', ["uri.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('close_stl.o', ["close.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('sha1_stl.o', ["sha1.cpp"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_utility_stl', ["utilities_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_uri_stl', ["uri_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_close_stl', ["close_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_sha1_stl', ["sha1_stl.o"], LIBS = BOOST_LIBS_CPP11)
+
+Return('prgs')

test/utility/close.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE close
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/close.hpp>
+#include <websocketpp/utilities.hpp>
+
+using namespace websocketpp;
+
+BOOST_AUTO_TEST_CASE( reserved_values ) {
+    BOOST_CHECK( !close::status::reserved(999) );
+    BOOST_CHECK( close::status::reserved(1004) );
+    BOOST_CHECK( close::status::reserved(1014) );
+    BOOST_CHECK( close::status::reserved(1016) );
+    BOOST_CHECK( close::status::reserved(2999) );
+    BOOST_CHECK( !close::status::reserved(1000) );
+}
+
+BOOST_AUTO_TEST_CASE( invalid_values ) {
+    BOOST_CHECK( close::status::invalid(0) );
+    BOOST_CHECK( close::status::invalid(999) );
+    BOOST_CHECK( !close::status::invalid(1000) );
+    BOOST_CHECK( close::status::invalid(1005) );
+    BOOST_CHECK( close::status::invalid(1006) );
+    BOOST_CHECK( close::status::invalid(1015) );
+    BOOST_CHECK( !close::status::invalid(2999) );
+    BOOST_CHECK( !close::status::invalid(3000) );
+    BOOST_CHECK( close::status::invalid(5000) );
+}
+
+BOOST_AUTO_TEST_CASE( value_extraction ) {
+    lib::error_code ec;
+    std::string payload = "oo";
+
+    // Value = 1000
+    payload[0] = 0x03;
+    payload[1] = char(0xe8);
+    BOOST_CHECK( close::extract_code(payload,ec) == close::status::normal );
+    BOOST_CHECK( !ec );
+
+    // Value = 1004
+    payload[0] = 0x03;
+    payload[1] = char(0xec);
+    BOOST_CHECK( close::extract_code(payload,ec) == 1004 );
+    BOOST_CHECK( ec == error::reserved_close_code );
+
+    // Value = 1005
+    payload[0] = 0x03;
+    payload[1] = char(0xed);
+    BOOST_CHECK( close::extract_code(payload,ec) == close::status::no_status );
+    BOOST_CHECK( ec == error::invalid_close_code );
+
+    // Value = 3000
+    payload[0] = 0x0b;
+    payload[1] = char(0xb8);
+    BOOST_CHECK( close::extract_code(payload,ec) == 3000 );
+    BOOST_CHECK( !ec );
+}
+
+BOOST_AUTO_TEST_CASE( extract_empty ) {
+    lib::error_code ec;
+    std::string payload = "";
+
+    BOOST_CHECK( close::extract_code(payload,ec) == close::status::no_status );
+    BOOST_CHECK( !ec );
+}
+
+BOOST_AUTO_TEST_CASE( extract_short ) {
+    lib::error_code ec;
+    std::string payload = "0";
+
+    BOOST_CHECK( close::extract_code(payload,ec) == close::status::protocol_error );
+    BOOST_CHECK( ec == error::bad_close_code );
+}
+
+BOOST_AUTO_TEST_CASE( extract_reason ) {
+    lib::error_code ec;
+    std::string payload = "00Foo";
+
+    BOOST_CHECK( close::extract_reason(payload,ec) == "Foo" );
+    BOOST_CHECK( !ec );
+
+    payload = "";
+    BOOST_CHECK( close::extract_reason(payload,ec) == "" );
+    BOOST_CHECK( !ec );
+
+    payload = "00";
+    BOOST_CHECK( close::extract_reason(payload,ec) == "" );
+    BOOST_CHECK( !ec );
+
+    payload = "000";
+    payload[2] = char(0xFF);
+
+    close::extract_reason(payload,ec);
+    BOOST_CHECK( ec == error::invalid_utf8 );
+}

test/utility/frame.cpp

@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE frame
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/frame.hpp>
+#include <websocketpp/utilities.hpp>
+
+using namespace websocketpp;
+
+BOOST_AUTO_TEST_CASE( basic_bits ) {
+    frame::basic_header h1(0x00,0x00); // all false
+    frame::basic_header h2(0xF0,0x80); // all true
+
+    // Read Values
+    BOOST_CHECK( frame::get_fin(h1) == false );
+    BOOST_CHECK( frame::get_rsv1(h1) == false );
+    BOOST_CHECK( frame::get_rsv2(h1) == false );
+    BOOST_CHECK( frame::get_rsv3(h1) == false );
+    BOOST_CHECK( frame::get_masked(h1) == false );
+
+    BOOST_CHECK( frame::get_fin(h2) == true );
+    BOOST_CHECK( frame::get_rsv1(h2) == true );
+    BOOST_CHECK( frame::get_rsv2(h2) == true );
+    BOOST_CHECK( frame::get_rsv3(h2) == true );
+    BOOST_CHECK( frame::get_masked(h2) == true );
+
+    // Set Values
+    frame::set_fin(h1,true);
+    BOOST_CHECK( h1.b0 == 0x80 );
+
+    frame::set_rsv1(h1,true);
+    BOOST_CHECK( h1.b0 == 0xC0 );
+
+    frame::set_rsv2(h1,true);
+    BOOST_CHECK( h1.b0 == 0xE0 );
+
+    frame::set_rsv3(h1,true);
+    BOOST_CHECK( h1.b0 == 0xF0 );
+
+    frame::set_masked(h1,true);
+    BOOST_CHECK( h1.b1 == 0x80 );
+}
+
+BOOST_AUTO_TEST_CASE( basic_constructors ) {
+    // Read Values
+    frame::basic_header h1(frame::opcode::TEXT,12,true,false);
+    BOOST_CHECK( frame::get_opcode(h1) == frame::opcode::TEXT );
+    BOOST_CHECK( frame::get_basic_size(h1) == 12 );
+    BOOST_CHECK( frame::get_fin(h1) == true );
+    BOOST_CHECK( frame::get_rsv1(h1) == false );
+    BOOST_CHECK( frame::get_rsv2(h1) == false );
+    BOOST_CHECK( frame::get_rsv3(h1) == false );
+    BOOST_CHECK( frame::get_masked(h1) == false );
+
+    frame::basic_header h2(frame::opcode::BINARY,0,false,false,false,true);
+    BOOST_CHECK( frame::get_opcode(h2) == frame::opcode::BINARY );
+    BOOST_CHECK( frame::get_basic_size(h2) == 0 );
+    BOOST_CHECK( frame::get_fin(h2) == false );
+    BOOST_CHECK( frame::get_rsv1(h2) == false );
+    BOOST_CHECK( frame::get_rsv2(h2) == true );
+    BOOST_CHECK( frame::get_rsv3(h2) == false );
+    BOOST_CHECK( frame::get_masked(h2) == false );
+}
+
+BOOST_AUTO_TEST_CASE( basic_size ) {
+    frame::basic_header h1(0x00,0x00); // length 0
+    frame::basic_header h2(0x00,0x01); // length 1
+    frame::basic_header h3(0x00,0x7D); // length 125
+    frame::basic_header h4(0x00,0x7E); // length 126
+    frame::basic_header h5(0x00,0x7F); // length 127
+    frame::basic_header h6(0x00,0x80); // length 0, mask bit set
+
+    BOOST_CHECK( frame::get_basic_size(h1) == 0 );
+    BOOST_CHECK( frame::get_basic_size(h2) == 1 );
+    BOOST_CHECK( frame::get_basic_size(h3) == 125 );
+    BOOST_CHECK( frame::get_basic_size(h4) == 126 );
+    BOOST_CHECK( frame::get_basic_size(h5) == 127 );
+    BOOST_CHECK( frame::get_basic_size(h6) == 0 );
+
+    /*frame::set_basic_size(h1,1);
+    BOOST_CHECK( h1.b1 == 0x01 );
+
+    frame::set_basic_size(h1,125);
+    BOOST_CHECK( h1.b1 == 0x7D );
+
+    frame::set_basic_size(h1,126);
+    BOOST_CHECK( h1.b1 == 0x7E );
+
+    frame::set_basic_size(h1,127);
+    BOOST_CHECK( h1.b1 == 0x7F );
+
+    frame::set_basic_size(h1,0);
+    BOOST_CHECK( h1.b1 == 0x00 );*/
+}
+
+BOOST_AUTO_TEST_CASE( basic_header_length ) {
+    frame::basic_header h1(0x82,0x00); // short binary frame, unmasked
+    frame::basic_header h2(0x82,0x80); // short binary frame, masked
+    frame::basic_header h3(0x82,0x7E); // medium binary frame, unmasked
+    frame::basic_header h4(0x82,0xFE); // medium binary frame, masked
+    frame::basic_header h5(0x82,0x7F); // jumbo binary frame, unmasked
+    frame::basic_header h6(0x82,0xFF); // jumbo binary frame, masked
+
+    BOOST_CHECK( frame::get_header_len(h1) == 2);
+    BOOST_CHECK( frame::get_header_len(h2) == 6);
+    BOOST_CHECK( frame::get_header_len(h3) == 4);
+    BOOST_CHECK( frame::get_header_len(h4) == 8);
+    BOOST_CHECK( frame::get_header_len(h5) == 10);
+    BOOST_CHECK( frame::get_header_len(h6) == 14);
+}
+
+BOOST_AUTO_TEST_CASE( basic_opcode ) {
+    frame::basic_header h1(0x00,0x00);
+
+    BOOST_CHECK( is_control(frame::opcode::CONTINUATION) == false);
+    BOOST_CHECK( is_control(frame::opcode::TEXT) == false);
+    BOOST_CHECK( is_control(frame::opcode::BINARY) == false);
+    BOOST_CHECK( is_control(frame::opcode::CLOSE) == true);
+    BOOST_CHECK( is_control(frame::opcode::PING) == true);
+    BOOST_CHECK( is_control(frame::opcode::PONG) == true);
+
+    BOOST_CHECK( frame::get_opcode(h1) == frame::opcode::CONTINUATION );
+}
+
+BOOST_AUTO_TEST_CASE( extended_header_basics ) {
+    frame::extended_header h1;
+    uint8_t h1_solution[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    frame::extended_header h2(uint16_t(255));
+    uint8_t h2_solution[12] = {0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    frame::extended_header h3(uint16_t(256),htonl(0x8040201));
+    uint8_t h3_solution[12] = {0x01, 0x00, 0x08, 0x04, 0x02, 0x01,
+                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    frame::extended_header h4(uint64_t(0x0807060504030201LL));
+    uint8_t h4_solution[12] = {0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+                               0x02, 0x01, 0x00, 0x00, 0x00, 0x00};
+
+    frame::extended_header h5(uint64_t(0x0807060504030201LL),htonl(0x8040201));
+    uint8_t h5_solution[12] = {0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+                               0x02, 0x01, 0x08, 0x04, 0x02, 0x01};
+
+    BOOST_CHECK( std::equal(h1_solution,h1_solution+12,h1.bytes) );
+    BOOST_CHECK( std::equal(h2_solution,h2_solution+12,h2.bytes) );
+    BOOST_CHECK( std::equal(h3_solution,h3_solution+12,h3.bytes) );
+    BOOST_CHECK( std::equal(h4_solution,h4_solution+12,h4.bytes) );
+    BOOST_CHECK( std::equal(h5_solution,h5_solution+12,h5.bytes) );
+}
+
+BOOST_AUTO_TEST_CASE( extended_header_extractors ) {
+    frame::basic_header h1(0x00,0x7E);
+    frame::extended_header e1(uint16_t(255));
+    BOOST_CHECK( get_extended_size(e1) == 255 );
+    BOOST_CHECK( get_payload_size(h1,e1) == 255 );
+    BOOST_CHECK( get_masking_key_offset(h1) == 2 );
+    BOOST_CHECK( get_masking_key(h1,e1).i == 0 );
+
+    frame::basic_header h2(0x00,0x7F);
+    frame::extended_header e2(uint64_t(0x0807060504030201LL));
+    BOOST_CHECK( get_jumbo_size(e2) == 0x0807060504030201LL );
+    BOOST_CHECK( get_payload_size(h2,e2) == 0x0807060504030201LL );
+    BOOST_CHECK( get_masking_key_offset(h2) == 8 );
+    BOOST_CHECK( get_masking_key(h2,e2).i == 0 );
+
+    frame::basic_header h3(0x00,0xFE);
+    frame::extended_header e3(uint16_t(255),0x08040201);
+    BOOST_CHECK( get_extended_size(e3) == 255 );
+    BOOST_CHECK( get_payload_size(h3,e3) == 255 );
+    BOOST_CHECK( get_masking_key_offset(h3) == 2 );
+    BOOST_CHECK( get_masking_key(h3,e3).i == 0x08040201 );
+
+    frame::basic_header h4(0x00,0xFF);
+    frame::extended_header e4(uint64_t(0x0807060504030201LL),0x08040201);
+    BOOST_CHECK( get_jumbo_size(e4) == 0x0807060504030201LL );
+    BOOST_CHECK( get_payload_size(h4,e4) == 0x0807060504030201LL );
+    BOOST_CHECK( get_masking_key_offset(h4) == 8 );
+    BOOST_CHECK( get_masking_key(h4,e4).i == 0x08040201 );
+
+    frame::basic_header h5(0x00,0x7D);
+    frame::extended_header e5;
+    BOOST_CHECK( get_payload_size(h5,e5) == 125 );
+}
+
+BOOST_AUTO_TEST_CASE( header_preparation ) {
+    frame::basic_header h1(0x81,0xFF); //
+    frame::extended_header e1(uint64_t(0xFFFFFLL),htonl(0xD5FB70EE));
+    std::string p1 = prepare_header(h1, e1);
+    uint8_t s1[14] = {0x81, 0xFF,
+                     0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF,
+                     0xD5, 0xFB, 0x70, 0xEE};
+
+    BOOST_CHECK( p1.size() == 14);
+    BOOST_CHECK( std::equal(p1.begin(),p1.end(),reinterpret_cast<char*>(s1)) );
+
+    frame::basic_header h2(0x81,0x7E); //
+    frame::extended_header e2(uint16_t(255));
+    std::string p2 = prepare_header(h2, e2);
+    uint8_t s2[4] = {0x81, 0x7E, 0x00, 0xFF};
+
+    BOOST_CHECK( p2.size() == 4);
+    BOOST_CHECK( std::equal(p2.begin(),p2.end(),reinterpret_cast<char*>(s2)) );
+}
+
+BOOST_AUTO_TEST_CASE( prepare_masking_key ) {
+    frame::masking_key_type key;
+
+    key.i = htonl(0x12345678);
+
+    if (sizeof(size_t) == 8) {
+        BOOST_CHECK(
+            frame::prepare_masking_key(key) == lib::net::_htonll(0x1234567812345678LL)
+        );
+    } else {
+        BOOST_CHECK( frame::prepare_masking_key(key) == htonl(0x12345678) );
+    }
+}
+
+BOOST_AUTO_TEST_CASE( prepare_masking_key2 ) {
+    frame::masking_key_type key;
+
+    key.i = htonl(0xD5FB70EE);
+
+    // One call
+    if (sizeof(size_t) == 8) {
+        BOOST_CHECK(
+            frame::prepare_masking_key(key) == lib::net::_htonll(0xD5FB70EED5FB70EELL)
+        );
+    } else {
+        BOOST_CHECK( frame::prepare_masking_key(key) == htonl(0xD5FB70EE) );
+    }
+}
+
+// TODO: figure out a way to run/test both 4 and 8 byte versions.
+BOOST_AUTO_TEST_CASE( circshift ) {
+    /*if (sizeof(size_t) == 8) {
+        size_t test = 0x0123456789abcdef;
+
+        BOOST_CHECK( frame::circshift_prepared_key(test,0) == 0x0123456789abcdef);
+        BOOST_CHECK( frame::circshift_prepared_key(test,1) == 0xef0123456789abcd);
+        BOOST_CHECK( frame::circshift_prepared_key(test,2) == 0xcdef0123456789ab);
+        BOOST_CHECK( frame::circshift_prepared_key(test,3) == 0xabcdef0123456789);
+    } else {
+        size_t test = 0x01234567;
+
+        BOOST_CHECK( frame::circshift_prepared_key(test,0) == 0x01234567);
+        BOOST_CHECK( frame::circshift_prepared_key(test,1) == 0x67012345);
+        BOOST_CHECK( frame::circshift_prepared_key(test,2) == 0x45670123);
+        BOOST_CHECK( frame::circshift_prepared_key(test,3) == 0x23456701);
+    }*/
+}
+
+BOOST_AUTO_TEST_CASE( block_byte_mask ) {
+    uint8_t input[15] = {0x00, 0x00, 0x00, 0x00,
+                         0x00, 0x00, 0x00, 0x00,
+                         0x00, 0x00, 0x00, 0x00,
+                         0x00, 0x00, 0x00};
+
+    uint8_t output[15];
+
+    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    byte_mask(input,input+15,output,key);
+
+    BOOST_CHECK( std::equal(output,output+15,masked) );
+}
+
+BOOST_AUTO_TEST_CASE( block_byte_mask_inplace ) {
+    uint8_t buffer[15] = {0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00};
+
+    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    byte_mask(buffer,buffer+15,key);
+
+    BOOST_CHECK( std::equal(buffer,buffer+15,masked) );
+}
+
+BOOST_AUTO_TEST_CASE( block_word_mask ) {
+    uint8_t input[15] =  {0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00};
+
+    uint8_t output[15];
+
+    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    word_mask_exact(input,output,15,key);
+
+    BOOST_CHECK( std::equal(output,output+15,masked) );
+}
+
+BOOST_AUTO_TEST_CASE( block_word_mask_inplace ) {
+    uint8_t buffer[15] = {0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00, 0x00,
+                          0x00, 0x00, 0x00};
+
+    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    word_mask_exact(buffer,15,key);
+
+    BOOST_CHECK( std::equal(buffer,buffer+15,masked) );
+}
+
+BOOST_AUTO_TEST_CASE( continuous_word_mask ) {
+    uint8_t input[16];
+    uint8_t output[16];
+
+    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x00};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    // One call
+    size_t pkey,pkey_temp;
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(input,16,0x00);
+    std::fill_n(output,16,0x00);
+    frame::word_mask_circ(input,output,15,pkey);
+    BOOST_CHECK( std::equal(output,output+16,masked) );
+
+    // calls not split on word boundaries
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(input,16,0x00);
+    std::fill_n(output,16,0x00);
+
+    pkey_temp = frame::word_mask_circ(input,output,7,pkey);
+    BOOST_CHECK( std::equal(output,output+7,masked) );
+    BOOST_CHECK( pkey_temp == frame::circshift_prepared_key(pkey,3) );
+
+    pkey_temp = frame::word_mask_circ(input+7,output+7,8,pkey_temp);
+    BOOST_CHECK( std::equal(output,output+16,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+}
+
+BOOST_AUTO_TEST_CASE( continuous_byte_mask ) {
+    uint8_t input[16];
+    uint8_t output[16];
+
+    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x00};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    // One call
+    size_t pkey,pkey_temp;
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(input,16,0x00);
+    std::fill_n(output,16,0x00);
+    frame::byte_mask_circ(input,output,15,pkey);
+    BOOST_CHECK( std::equal(output,output+16,masked) );
+
+    // calls not split on word boundaries
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(input,16,0x00);
+    std::fill_n(output,16,0x00);
+
+    pkey_temp = frame::byte_mask_circ(input,output,7,pkey);
+    BOOST_CHECK( std::equal(output,output+7,masked) );
+    BOOST_CHECK( pkey_temp == frame::circshift_prepared_key(pkey,3) );
+
+    pkey_temp = frame::byte_mask_circ(input+7,output+7,8,pkey_temp);
+    BOOST_CHECK( std::equal(output,output+16,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+}
+
+BOOST_AUTO_TEST_CASE( continuous_word_mask_inplace ) {
+    uint8_t buffer[16];
+
+    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x00};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    // One call
+    size_t pkey,pkey_temp;
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(buffer,16,0x00);
+    frame::word_mask_circ(buffer,15,pkey);
+    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
+
+    // calls not split on word boundaries
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(buffer,16,0x00);
+
+    pkey_temp = frame::word_mask_circ(buffer,7,pkey);
+    BOOST_CHECK( std::equal(buffer,buffer+7,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+
+    pkey_temp = frame::word_mask_circ(buffer+7,8,pkey_temp);
+    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+}
+
+BOOST_AUTO_TEST_CASE( continuous_byte_mask_inplace ) {
+    uint8_t buffer[16];
+
+    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x03,
+                          0x00, 0x01, 0x02, 0x00};
+
+    frame::masking_key_type key;
+    key.c[0] = 0x00;
+    key.c[1] = 0x01;
+    key.c[2] = 0x02;
+    key.c[3] = 0x03;
+
+    // One call
+    size_t pkey,pkey_temp;
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(buffer,16,0x00);
+    frame::byte_mask_circ(buffer,15,pkey);
+    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
+
+    // calls not split on word boundaries
+    pkey = frame::prepare_masking_key(key);
+    std::fill_n(buffer,16,0x00);
+
+    pkey_temp = frame::byte_mask_circ(buffer,7,pkey);
+    BOOST_CHECK( std::equal(buffer,buffer+7,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+
+    pkey_temp = frame::byte_mask_circ(buffer+7,8,pkey_temp);
+    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
+    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
+}
+
+BOOST_AUTO_TEST_CASE( continuous_word_mask2 ) {
+    uint8_t buffer[12] = {0xA6, 0x15, 0x97, 0xB9,
+                          0x81, 0x50, 0xAC, 0xBA,
+                          0x9C, 0x1C, 0x9F, 0xF4};
+
+    uint8_t unmasked[12] = {0x48, 0x65, 0x6C, 0x6C,
+                            0x6F, 0x20, 0x57, 0x6F,
+                            0x72, 0x6C, 0x64, 0x21};
+
+    frame::masking_key_type key;
+    key.c[0] = 0xEE;
+    key.c[1] = 0x70;
+    key.c[2] = 0xFB;
+    key.c[3] = 0xD5;
+
+    // One call
+    size_t pkey;
+    pkey = frame::prepare_masking_key(key);
+    frame::word_mask_circ(buffer,12,pkey);
+    BOOST_CHECK( std::equal(buffer,buffer+12,unmasked) );
+}

test/utility/sha1.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE sha1
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/sha1/sha1.hpp>
+#include <websocketpp/utilities.hpp>
+
+BOOST_AUTO_TEST_SUITE ( sha1 )
+
+BOOST_AUTO_TEST_CASE( sha1_test_a ) {
+    unsigned char hash[20];
+    unsigned char reference[20] = {0xa9, 0x99, 0x3e, 0x36, 0x47,
+                                   0x06, 0x81, 0x6a, 0xba, 0x3e,
+                                   0x25, 0x71, 0x78, 0x50, 0xc2,
+                                   0x6c, 0x9c, 0xd0, 0xd8, 0x9d};
+
+    websocketpp::sha1::calc("abc",3,hash);
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
+}
+
+BOOST_AUTO_TEST_CASE( sha1_test_b ) {
+    unsigned char hash[20];
+    unsigned char reference[20] = {0x84, 0x98, 0x3e, 0x44, 0x1c,
+                                   0x3b, 0xd2, 0x6e, 0xba, 0xae,
+                                   0x4a, 0xa1, 0xf9, 0x51, 0x29,
+                                   0xe5, 0xe5, 0x46, 0x70, 0xf1};
+
+    websocketpp::sha1::calc(
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",56,hash);
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
+}
+
+BOOST_AUTO_TEST_CASE( sha1_test_c ) {
+    std::string input;
+    unsigned char hash[20];
+    unsigned char reference[20] = {0x34, 0xaa, 0x97, 0x3c, 0xd4,
+                                   0xc4, 0xda, 0xa4, 0xf6, 0x1e,
+                                   0xeb, 0x2b, 0xdb, 0xad, 0x27,
+                                   0x31, 0x65, 0x34, 0x01, 0x6f};
+
+    for (int i = 0; i < 1000000; i++) {
+        input += 'a';
+    }
+
+    websocketpp::sha1::calc(input.c_str(),input.size(),hash);
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/utility/uri.cpp

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE uri
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/uri.hpp>
+
+// Test a regular valid ws URI
+BOOST_AUTO_TEST_CASE( uri_valid ) {
+    websocketpp::uri uri("ws://localhost:9000/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( !uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "ws");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+    BOOST_CHECK_EQUAL( uri.get_query(), "" );
+}
+
+// Test a regular valid ws URI
+BOOST_AUTO_TEST_CASE( uri_valid_no_port_unsecure ) {
+    websocketpp::uri uri("ws://localhost/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( !uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "ws");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 80 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+}
+
+// Valid URI with no port (secure)
+BOOST_AUTO_TEST_CASE( uri_valid_no_port_secure ) {
+    websocketpp::uri uri("wss://localhost/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 443 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+}
+
+// Valid URI with no resource
+BOOST_AUTO_TEST_CASE( uri_valid_no_resource ) {
+    websocketpp::uri uri("wss://localhost:9000");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
+}
+
+// Valid URI IPv6 Literal
+BOOST_AUTO_TEST_CASE( uri_valid_ipv6_literal ) {
+    websocketpp::uri uri("wss://[::1]:9000/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "::1");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+}
+
+// Valid URI with more complicated host
+BOOST_AUTO_TEST_CASE( uri_valid_2 ) {
+    websocketpp::uri uri("wss://thor-websocket.zaphoyd.net:88/");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "thor-websocket.zaphoyd.net");
+    BOOST_CHECK_EQUAL( uri.get_port(), 88 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
+}
+
+
+// Invalid URI (port too long)
+BOOST_AUTO_TEST_CASE( uri_invalid_long_port ) {
+    websocketpp::uri uri("wss://localhost:900000/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid URI (bogus scheme method)
+BOOST_AUTO_TEST_CASE( uri_invalid_scheme ) {
+    websocketpp::uri uri("foo://localhost:9000/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Valid URI (http method)
+BOOST_AUTO_TEST_CASE( uri_http_scheme ) {
+    websocketpp::uri uri("http://localhost:9000/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( !uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "http");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+}
+
+// Valid URI IPv4 literal
+BOOST_AUTO_TEST_CASE( uri_valid_ipv4_literal ) {
+    websocketpp::uri uri("wss://127.0.0.1:9000/chat");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "127.0.0.1");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
+}
+
+// Valid URI complicated resource path
+BOOST_AUTO_TEST_CASE( uri_valid_3 ) {
+    websocketpp::uri uri("wss://localhost:9000/chat/foo/bar");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat/foo/bar" );
+}
+
+// Invalid URI broken method separator
+BOOST_AUTO_TEST_CASE( uri_invalid_method_separator ) {
+    websocketpp::uri uri("wss:/localhost:9000/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid URI port > 65535
+BOOST_AUTO_TEST_CASE( uri_invalid_gt_16_bit_port ) {
+    websocketpp::uri uri("wss:/localhost:70000/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid URI includes uri fragment
+BOOST_AUTO_TEST_CASE( uri_invalid_fragment ) {
+    websocketpp::uri uri("wss:/localhost:70000/chat#foo");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid URI with no brackets around IPv6 literal
+BOOST_AUTO_TEST_CASE( uri_invalid_bad_v6_literal_1 ) {
+    websocketpp::uri uri("wss://::1/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid URI with port and no brackets around IPv6 literal
+BOOST_AUTO_TEST_CASE( uri_invalid_bad_v6_literal_2 ) {
+    websocketpp::uri uri("wss://::1:2009/chat");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Valid URI complicated resource path with query
+BOOST_AUTO_TEST_CASE( uri_valid_4 ) {
+    websocketpp::uri uri("wss://localhost:9000/chat/foo/bar?foo=bar");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
+    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat/foo/bar?foo=bar" );
+    BOOST_CHECK_EQUAL( uri.get_query(), "foo=bar" );
+}
+
+// Valid URI with a mapped v4 ipv6 literal
+BOOST_AUTO_TEST_CASE( uri_valid_v4_mapped ) {
+    websocketpp::uri uri("wss://[0000:0000:0000:0000:0000:0000:192.168.1.1]:9000/");
+
+    BOOST_CHECK( uri.get_valid() );
+    BOOST_CHECK( uri.get_secure() );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
+    BOOST_CHECK_EQUAL( uri.get_host(), "0000:0000:0000:0000:0000:0000:192.168.1.1");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
+}
+
+// Valid URI with a v6 address with mixed case
+BOOST_AUTO_TEST_CASE( uri_valid_v6_mixed_case ) {
+    websocketpp::uri uri("wss://[::10aB]:9000/");
+
+    BOOST_CHECK( uri.get_valid() == true );
+    BOOST_CHECK( uri.get_secure() == true );
+    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
+    BOOST_CHECK_EQUAL( uri.get_host(), "::10aB");
+    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
+    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
+}
+
+// Valid URI with a v6 address with mixed case
+BOOST_AUTO_TEST_CASE( uri_invalid_no_scheme ) {
+    websocketpp::uri uri("myserver.com");
+
+    BOOST_CHECK( !uri.get_valid() );
+}
+
+// Invalid IPv6 literal
+/*BOOST_AUTO_TEST_CASE( uri_invalid_v6_nonhex ) {
+    websocketpp::uri uri("wss://[g::1]:9000/");
+
+    BOOST_CHECK( uri.get_valid() == false );
+}*/
+
+// TODO: tests for the other two constructors

test/utility/utilities.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2011, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+//#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE utility
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <websocketpp/utilities.hpp>
+
+BOOST_AUTO_TEST_SUITE ( utility )
+
+BOOST_AUTO_TEST_CASE( substr_found ) {
+    std::string haystack = "abc123";
+    std::string needle = "abc";
+
+    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) ==haystack.begin());
+}
+
+BOOST_AUTO_TEST_CASE( substr_found_ci ) {
+    std::string haystack = "abc123";
+    std::string needle = "aBc";
+
+    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) ==haystack.begin());
+}
+
+BOOST_AUTO_TEST_CASE( substr_not_found ) {
+    std::string haystack = "abd123";
+    std::string needle = "abcd";
+
+    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) == haystack.end());
+}
+
+BOOST_AUTO_TEST_CASE( to_lower ) {
+    std::string in = "AbCd";
+
+    BOOST_CHECK_EQUAL(websocketpp::utility::to_lower(in), "abcd");
+}
+
+BOOST_AUTO_TEST_CASE( string_replace_all ) {
+    std::string source = "foo \"bar\" baz";
+    std::string dest = "foo \\\"bar\\\" baz";
+
+    using websocketpp::utility::string_replace_all;
+    BOOST_CHECK_EQUAL(string_replace_all(source,"\"","\\\""),dest);
+}
+
+BOOST_AUTO_TEST_SUITE_END()