fix building for linux (#1)

Author: pdeligia

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 0.1)
+cmake_minimum_required(VERSION 3.8)
 project("cpp_systematic_testing" CXX)
 
 set(CMAKE_CXX_STANDARD 17)

include/systematic_testing.h

@@ -5,7 +5,9 @@
 #define SYSTEMATIC_TESTING_H
 
 #include <algorithm>
+#include <atomic>
 #include <chrono>
+#include <cmath>
 #include <condition_variable>
 #include <functional>
 #include <iostream>
@@ -21,10 +23,24 @@
 #include <tuple>
 #include <vector>
 
-#ifdef SYSTEST_EXPORT
-#   define SYSTEST_API __declspec(dllexport)
-#else
-#   define SYSTEST_API __declspec(dllimport)
+#ifdef __linux__
+#   ifdef SYSTEST_EXPORT
+#      define SYSTEST_API __attribute__((visibility("default")))
+#   else
+#      define SYSTEST_API 
+#   endif
+#elif _WIN32
+#   ifdef SYSTEST_EXPORT
+#      define SYSTEST_API __declspec(dllexport)
+#   else
+#      define SYSTEST_API __declspec(dllimport)
+#   endif
+#else 
+#   ifdef SYSTEST_EXPORT
+#      define SYSTEST_API 
+#   else
+#      define SYSTEST_API 
+#   endif
 #endif
 
 namespace SystematicTesting
@@ -289,7 +305,7 @@ namespace SystematicTesting
     {
     private:
         // Give private access to the test engine.
-        friend class TestEngine;
+        friend class SystematicTesting::TestEngine;
 
     public:
         // Returns the number of iterations performed.
@@ -666,7 +682,7 @@ namespace SystematicTesting
         {
         private:
             // Give private access to the test engine.
-            friend class TestEngine;
+            friend class SystematicTesting::TestEngine;
 
             // The creation sequence vector of this operation.
             std::vector<size_t> m_creation_seq;

test/controlled_task.h

@@ -15,60 +15,57 @@
 using namespace std::chrono_literals;
 using namespace SystematicTesting;
 
-namespace
+template<typename ResultType>
+class ControlledTaskBase
 {
-    template<typename ResultType>
-    class ControlledTaskBase
+public:
+    explicit ControlledTaskBase(std::function<ResultType()> func) :
+        m_test_engine(GetTestEngine()),
+        m_thread(),
+        m_func(func),
+        m_result(std::nullopt)
     {
-    public:
-        explicit ControlledTaskBase(std::function<ResultType()> func) :
-            m_test_engine(GetTestEngine()),
-            m_thread(),
-            m_func(func),
-            m_result(std::nullopt)
-        {
-            
-        }
+        
+    }
 
-        virtual ~ControlledTaskBase()
+    virtual ~ControlledTaskBase()
+    {
+        if (m_thread->joinable())
         {
-            if (m_thread->joinable())
-            {
-                m_thread->join();
-            }
+            m_thread->join();
         }
+    }
 
-        void start()
+    void start()
+    {
+        size_t op_id = m_test_engine->create_next_operation().value();
+        m_thread = std::make_unique<std::thread>([this, op_id]()
         {
-            size_t op_id = m_test_engine->create_next_operation().value();
-            m_thread = std::make_unique<std::thread>([this, op_id]()
-            {
-                m_test_engine->start_operation(op_id);
-                execute(m_func, op_id);
-                m_test_engine->complete_current_operation();
-            });
-
-            m_test_engine->schedule_next_operation();
-        }
+            m_test_engine->start_operation(op_id);
+            execute(m_func, op_id);
+            m_test_engine->complete_current_operation();
+        });
 
-        void wait()
-        {
-            m_test_engine->pause_operation_until_condition([this]() {
-                return m_result.has_value();
-            });
-        }
+        m_test_engine->schedule_next_operation();
+    }
+
+    void wait()
+    {
+        m_test_engine->pause_operation_until_condition([this]() {
+            return m_result.has_value();
+        });
+    }
 
-    protected:
-        std::optional<std::any> m_result;
+protected:
+    std::optional<std::any> m_result;
 
-        virtual void execute(std::function<ResultType()>& func, size_t op_id) = 0;
+    virtual void execute(std::function<ResultType()>& func, size_t op_id) = 0;
 
-    private:
-        TestEngine* m_test_engine;
-        std::unique_ptr<std::thread> m_thread;
-        std::function<ResultType()> m_func;
-    };
-}
+private:
+    TestEngine* m_test_engine;
+    std::unique_ptr<std::thread> m_thread;
+    std::function<ResultType()> m_func;
+};
 
 template<typename ResultType>
 class ControlledTask final : public ControlledTaskBase<ResultType>