Enabling building and running tests on Linux

CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required (VERSION 2.8.11)
+project (signalrclient)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fPIC -L -lcpprest")
+
+set(CPPREST_INCLUDE_DIR "" CACHE FILEPATH "Path to casablanca include dir")
+
+include_directories (
+include
+"${CPPREST_INCLUDE_DIR}")
+
+find_library(CPPREST_SO NAMES "cpprest" PATHS ${CPPREST_LIB_DIR} REQUIRED)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
+
+add_subdirectory(src/signalrclient)
+add_subdirectory(test)

include/signalrclient/hub_proxy.h

@@ -45,12 +45,6 @@ namespace signalr
             return invoke_json(method_name, web::json::value().array(), on_progress);
         }
 
-        template<>
-        pplx::task<void> invoke<void>(const utility::string_t& method_name, const on_progress_handler& on_progress)
-        {
-            return invoke_void(method_name, web::json::value().array(), on_progress);
-        }
-
         template<typename T>
         pplx::task<T> invoke(const utility::string_t& method_name, const web::json::value& arguments,
             const on_progress_handler& on_progress = [](const web::json::value&){})
@@ -59,13 +53,6 @@ namespace signalr
             return invoke_json(method_name, arguments, on_progress);
         }
 
-        template<>
-        pplx::task<void> invoke<void>(const utility::string_t& method_name, const web::json::value& arguments,
-            const on_progress_handler& on_progress)
-        {
-            return invoke_void(method_name, arguments, on_progress);
-        }
-
     private:
         std::shared_ptr<internal_hub_proxy> m_pImpl;
 
@@ -74,4 +61,17 @@ namespace signalr
         SIGNALRCLIENT_API pplx::task<void> __cdecl invoke_void(const utility::string_t& method_name, const web::json::value& arguments,
             const on_progress_handler& on_progress);
     };
+
+    template<>
+    inline pplx::task<void> hub_proxy::invoke<void>(const utility::string_t& method_name, const on_progress_handler& on_progress)
+    {
+        return invoke_void(method_name, web::json::value().array(), on_progress);
+    }
+
+    template<>
+    inline pplx::task<void> hub_proxy::invoke<void>(const utility::string_t& method_name, const web::json::value& arguments,
+        const on_progress_handler& on_progress)
+    {
+        return invoke_void(method_name, arguments, on_progress);
+    }
 }

src/signalrclient/CMakeLists.txt

@@ -0,0 +1,27 @@
+
+
+set (SOURCES
+ callback_manager.cpp
+ connection.cpp
+ connection_impl.cpp
+ default_websocket_client.cpp
+ http_sender.cpp
+ hub_connection.cpp
+ hub_connection_impl.cpp
+ hub_proxy.cpp
+ internal_hub_proxy.cpp
+ logger.cpp
+ request_sender.cpp
+ stdafx.cpp
+ trace_log_writer.cpp
+ transport.cpp
+ transport_factory.cpp
+ url_builder.cpp
+ web_request.cpp
+ web_request_factory.cpp
+ websocket_transport.cpp
+)
+
+add_library (signalrclient SHARED ${SOURCES})
+
+target_link_libraries(signalrclient ${CPPREST_SO})

src/signalrclient/callback_manager.h

@@ -26,7 +26,7 @@ namespace signalr
         void clear(const web::json::value& arguments);
 
     private:
-        std::atomic<int> m_id = 0;
+        std::atomic<int> m_id { 0 };
         std::unordered_map<utility::string_t, std::function<void(const web::json::value&)>> m_callbacks;
         std::mutex m_map_lock;
         const web::json::value m_dtor_clear_arguments;

src/signalrclient/connection_impl.cpp

@@ -10,6 +10,7 @@
 #include "request_sender.h"
 #include "url_builder.h"
 #include "trace_log_writer.h"
+#include "make_unique.h"
 
 namespace signalr
 {
@@ -23,7 +24,7 @@ namespace signalr
     std::shared_ptr<connection_impl> connection_impl::create(const utility::string_t& url, const utility::string_t& query_string,
         trace_level trace_level, const std::shared_ptr<log_writer>& log_writer)
     {
-        return connection_impl::create(url, query_string, trace_level, log_writer, std::make_unique<web_request_factory>(), std::make_unique<transport_factory>());
+        return connection_impl::create(url, query_string, trace_level, log_writer, std::make_unique<web_request_factory>(), std::unique_ptr<transport_factory>(new transport_factory));
     }
 
     std::shared_ptr<connection_impl> connection_impl::create(const utility::string_t& url, const utility::string_t& query_string, trace_level trace_level,
@@ -372,7 +373,7 @@ namespace signalr
         auto transport = m_transport;
 
         auto connection_state = get_connection_state();
-        if (connection_state != connection_state::connected || !transport)
+        if (connection_state != signalr::connection_state::connected || !transport)
         {
             return pplx::task_from_exception<void>(std::runtime_error(
                 std::string{ "cannot send data when the connection is not in the connected state. current connection state: " }
@@ -779,11 +780,11 @@ namespace signalr
 
     void connection_impl::ensure_disconnected(const std::string& error_message)
     {
-        auto connection_state = get_connection_state();
-        if (connection_state != connection_state::disconnected)
+        auto state = get_connection_state();
+        if (state != connection_state::disconnected)
         {
             throw std::runtime_error(error_message + std::string{"current connection state: "}
-                .append(utility::conversions::to_utf8string(translate_connection_state(connection_state))));
+                .append(utility::conversions::to_utf8string(translate_connection_state(state))));
         }
     }
 

src/signalrclient/event.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <assert.h>
+#include <condition_variable>
 #include <mutex>
 
 namespace signalr
@@ -47,7 +49,7 @@ namespace signalr
             {
                 std::chrono::milliseconds period(timeout);
                 auto status = m_condition.wait_for(lock, period, [this]() { return m_signaled; });
-                _ASSERTE(status == m_signaled);
+                assert(status == m_signaled);
                 // Return 0 if the wait completed as a result of signaling the event. Otherwise, return timeout_infinite
                 return status ? 0 : event::timeout_infinite;
             }
@@ -58,4 +60,4 @@ namespace signalr
             return wait(event::timeout_infinite);
         }
     };
-}
+}

src/signalrclient/hub_connection_impl.cpp

@@ -5,6 +5,7 @@
 #include "hub_connection_impl.h"
 #include "signalrclient/hub_exception.h"
 #include "trace_log_writer.h"
+#include "make_unique.h"
 
 namespace signalr
 {

src/signalrclient/logger.cpp

@@ -39,15 +39,15 @@ namespace signalr
     {
         switch (trace_level)
         {
-        case trace_level::messages:
+        case signalr::trace_level::messages:
             return _XPLATSTR("message");
-        case trace_level::state_changes:
+        case signalr::trace_level::state_changes:
             return _XPLATSTR("state change");
-        case trace_level::events:
+        case signalr::trace_level::events:
             return _XPLATSTR("event");
-        case trace_level::errors:
+        case signalr::trace_level::errors:
             return _XPLATSTR("error");
-        case trace_level::info:
+        case signalr::trace_level::info:
             return _XPLATSTR("info");
         default:
             _ASSERTE(false);

src/signalrclient/make_unique.h

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#pragma once
+
+#if defined (__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9))
+
+#include <memory>
+
+namespace std
+{
+    template<typename T, typename... Args>
+    std::unique_ptr<T> make_unique(Args&&... args)
+    {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+}
+#endif

src/signalrclient/transport_factory.cpp

@@ -12,13 +12,13 @@ namespace signalr
         std::function<void(const utility::string_t&)> process_response_callback,
         std::function<void(const std::exception&)> error_callback)
     {
-        if (transport_type == transport_type::websockets)
+        if (transport_type == signalr::transport_type::websockets)
         {
             return websocket_transport::create([headers](){ return std::make_shared<default_websocket_client>(headers); },
                 logger, process_response_callback, error_callback);
         }
 
-        throw std::exception("not implemented");
+        throw std::runtime_error("not implemented");
     }
 
     transport_factory::~transport_factory()

src/signalrclient/web_request_factory.cpp

@@ -3,6 +3,7 @@
 
 #include "stdafx.h"
 #include "web_request_factory.h"
+#include "make_unique.h"
 
 namespace signalr
 {

test/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_subdirectory (gtest-1.7.0)
+enable_testing()
+include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
+
+add_subdirectory (signalrclienttests)

test/signalrclienttests/CMakeLists.txt

@@ -0,0 +1,31 @@
+
+
+set (SOURCES 
+ callback_manager_tests.cpp
+ case_insensitive_comparison_utils_tests.cpp
+ connection_impl_tests.cpp
+ http_sender_tests.cpp
+ hub_connection_impl_tests.cpp
+ hub_exception_tests.cpp
+ internal_hub_proxy_tests.cpp
+ logger_tests.cpp
+ memory_log_writer.cpp
+ request_sender_tests.cpp
+ signalrclienttests.cpp
+ stdafx.cpp
+ test_transport_factory.cpp
+ test_utils.cpp
+ test_web_request_factory.cpp
+ test_websocket_client.cpp
+ url_builder_tests.cpp
+ web_request_stub.cpp
+ web_request_tests.cpp
+ websocket_transport_tests.cpp
+)
+
+include_directories(
+    ../../src/signalrclient)
+
+add_executable (signalrclienttests ${SOURCES})
+target_link_libraries(signalrclienttests gtest gtest_main signalrclient ${CPPREST_SO})
+add_test(signalrclienttests signalrclienttests)