text: /*
   * Copyright (c) 2015, 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/config/asio_no_tls_client.hpp>
  #include <websocketpp/client.hpp>
  #include <websocketpp/extensions/permessage_deflate/enabled.hpp>
  
  #include <iostream>
  
  struct deflate_config : public websocketpp::config::asio_client {
      typedef deflate_config type;
      typedef asio_client 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;
          
      /// permessage_compress extension
      struct permessage_deflate_config {};
  
      typedef websocketpp::extensions::permessage_deflate::enabled
          <permessage_deflate_config> permessage_deflate_type;
  };
  
  typedef websocketpp::client<deflate_config> client;
  
  using websocketpp::lib::placeholders::_1;
  using websocketpp::lib::placeholders::_2;
  using websocketpp::lib::bind;
  
  // pull out the type of messages sent by our config
  typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
  
  int case_count = 0;
  
  void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
      client::connection_ptr con = c->get_con_from_hdl(hdl);
  
      if (con->get_resource() == "/getCaseCount") {
          std::cout << "Detected " << msg->get_payload() << " test cases."
                    << std::endl;
          case_count = atoi(msg->get_payload().c_str());
      } else {
          c->send(hdl, msg->get_payload(), msg->get_opcode());
      }
  }
  
  int main(int argc, char* argv[]) {
      // Create a server endpoint
      client c;
  
      std::string uri = "ws://localhost:9001";
  
      if (argc == 2) {
          uri = argv[1];
      }
  
      try {
          // We expect there to be a lot of errors, so suppress them
          c.clear_access_channels(websocketpp::log::alevel::all);
          c.clear_error_channels(websocketpp::log::elevel::all);
  
          // Initialize ASIO
          c.init_asio();
  
          // Register our handlers
          c.set_message_handler(bind(&on_message,&c,::_1,::_2));
  
          websocketpp::lib::error_code ec;
          client::connection_ptr con = c.get_connection(uri+"/getCaseCount", ec);
          c.connect(con);
  
          // Start the ASIO io_service run loop
          c.run();
  
          std::cout << "case count: " << case_count << std::endl;
  
          for (int i = 1; i <= case_count; i++) {
              c.reset();
  
              std::stringstream url;
  
              url << uri << "/runCase?case=" << i << "&agent="
                  << websocketpp::user_agent;
  
              con = c.get_connection(url.str(), ec);
  
              c.connect(con);
  
              c.run();
          }
  
          std::cout << "done" << std::endl;
  
      } catch (websocketpp::exception const & e) {
          std::cout << e.what() << std::endl;
      }
  }
  