Merge branch '151-augment-coverage' into develop

Author: HerbertKoelman

CHANGELOG

@@ -1,5 +1,9 @@
 1.9.0
+- better comments in sync_queue (#157)
+- conditional_variable tests (#154)
+- new exception tests (#153)#
 - fix SONAR detected issues (#149)
+- bug fixing: #155, #156
 v1.8.0
 - integrate GTest as an external module (#79)
 - use CMake

include/pthread/condition_variable.hpp

@@ -195,10 +195,17 @@ namespace pthread {
 
     // constructor/destructor ------------------------------------------------
 
+    /** construct a new condition_variable (pthread_cond_init).
+     */
     condition_variable ();
+
+    /** destroy a condition_variable (pthread_cond_destroy)
+     *
+     */
     virtual ~condition_variable();
 
   private:
+
     void milliseconds( int milliseconds);
 
     timespec timeout;
@@ -231,7 +238,7 @@ namespace pthread {
     int rc = 0;
     cv_status status = no_timeout;
 
-    milliseconds(millis); // update timeou
+    milliseconds(millis); // update timeout
     bool stop_waiting = lambda(); // returns ​false if the waiting should be continued.
 
     while((! stop_waiting) && (status == no_timeout)){

include/pthread/exceptions.hpp

@@ -59,7 +59,6 @@ namespace pthread {
 
   private:
     std::string  _message;
-    //const char  *_message;
     int          _pthread_errno;
 
   };
@@ -109,16 +108,12 @@ namespace pthread {
   class condition_variable_exception: public pthread_exception {
   public:
 
-    /** thrown when mutex actions fail
+    /** thrown when condition variable actions fail
      *
      * @param message short description
      * @param pthread_errno error returned by the pthread function
      */
-    condition_variable_exception( const std::string &message, const int pthread_errno = -1);
-
-    virtual ~condition_variable_exception(){
-      // Intentionally unimplemented...
-    };
+    explicit condition_variable_exception( const std::string &message = "conditional_variable_exception", const int pthread_errno = -1);
   };
 
   /** thrown to indicate that something went wrong with a thread */

include/pthread/mutex.hpp

@@ -46,14 +46,15 @@ namespace pthread {
         void lock();
 
         /**
-         The function pthread_mutex_trylock is identical to pthread_mutex_lock except tha
-         if the mutex object referenced by mutex is currently locked (by any thread,
-         including the current thread), the call returns immediately.
-
-         @throw mutex_exception if error conditions preventing this method to succeed.
-         @see lock
+         * The function pthread_mutex_trylock is identical to pthread_mutex_lock except that
+         * if the mutex object referenced by mutex is currently locked (by any thread,
+         * including the current thread), the call returns immediately.
+         *
+         * @return
+         * @throw mutex_exception if error conditions preventing this method to succeed.
+         * @see lock
          */
-        void try_lock();
+        bool try_lock();
 
         /**
          The pthread_mutex_unlock function releases the mutex object referenced by mutex.  The manner in which a mutex is released is dependent upon the mutex's type attribute. If there are threads blocked on the mutex object referenced by mutex when unlock is called, resulting in the mutex becoming available, the scheduling policy is used to determine which thread shall acquire the mutex.

include/pthread/pthread.hpp

@@ -33,7 +33,7 @@
 namespace pthread {
 
   /** @return library version */
-  extern "C" const char *cpp_pthread_version();
+  const char *cpp_pthread_version();
 
 }
 #endif /* pthread_pthread_hpp */

include/pthread/sync_queue.hpp

@@ -53,7 +53,9 @@ namespace pthread {
        */
       void put (const T& item);
 
-      /** Put an item in the queue (wait if size >= max_size).
+      /** Put an item in the queue.
+       *
+       * If the queue size is greater or equal to max_size, then wait for the wiat-time millis for the queue to empty a bit.
        *
        * @param item item to store in the queue
        * @param wait_time millis to wait for the queue to free a slo
@@ -62,13 +64,13 @@ namespace pthread {
 
       /** Get an item from the queue.
        *
-       * If the queue is empty, get waits for an item to be put.
+       * If the queue is empty,  the method blocks until an item is entered in the queue.
        *
        * @param item item that will receive an item found onto the queue.
        */
       void get ( T& item);
 
-      /** Get an item from the queue, if empty wait for one during duration milliseconds.
+      /** Get an item from the queue, if the queue is empty, then wait for an element wait_time milliseconds.
        *
        * @param item item that will receive an item found onto the queue.
        * @param wait_time duration we are willing to wait for a new item.

src/condition_variable.cpp

@@ -91,10 +91,13 @@ namespace pthread {
   }
 
   condition_variable::~condition_variable () {
+      pthread_cond_destroy(&_condition);
+/* NOSONAR
     int rc = pthread_cond_destroy(&_condition);
     if (rc != 0){
-      throw pthread_exception("pthread condition variable destroy failed.", rc);
+      throw condition_variable_exception("pthread condition variable destroy failed.", rc);
     }
+*/
   }
 
 } // namespace pthread

src/mutex.cpp

@@ -10,38 +10,43 @@
 
 namespace pthread {
 
-  mutex::mutex () {
-    auto rc = pthread_mutex_init (&_mutex, NULL);
-    if ( rc != 0 ) {
-      throw mutex_exception ( "In constructor of mutex pthread_mutex_init(&mutex, NULL) failed. ", rc );
+    mutex::mutex() {
+        auto rc = pthread_mutex_init(&_mutex, NULL);
+        if (rc != 0) {
+            throw mutex_exception("In constructor of mutex pthread_mutex_init(&mutex, NULL) failed. ", rc);
+        }
     }
-  }
 
-  mutex::~mutex () {
-    pthread_mutex_destroy (&_mutex);
-  }
+    mutex::~mutex() {
+        pthread_mutex_destroy(&_mutex);
+    }
 
-  void mutex::lock () {
-    int rc = -1;
-    rc = pthread_mutex_lock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_lock failed.", rc);
+    void mutex::lock() {
+        int rc = -1;
+        rc = pthread_mutex_lock(&_mutex);
+        if (rc != 0) {
+            throw mutex_exception("pthread_mutex_lock failed.", rc);
+        }
     }
-  }
 
-  void mutex::try_lock () {
+    bool mutex::try_lock() {
+        bool status = false;
+
+        auto rc = pthread_mutex_trylock(&_mutex);
+        if (rc == 0) {
+            status = true;
+        } else {
+            throw mutex_exception("pthread_mutex_trylock failed, already locked.", rc);
+        }
 
-    auto rc = pthread_mutex_trylock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_trylock failed, already locked.", rc);
+        return status ;
     }
-  }
 
-  void mutex::unlock () {
-    auto rc = pthread_mutex_unlock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_unlock failed.", rc);
+    void mutex::unlock() {
+        auto rc = pthread_mutex_unlock(&_mutex);
+        if (rc != 0) {
+            throw mutex_exception("pthread_mutex_unlock failed.", rc);
+        }
     }
-  }
 
 }

tests/CMakeLists.txt

@@ -3,8 +3,11 @@ if (GCOV AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"))
     set(GCOV_LIB gcov)
 endif()
 
-message(STATUS "Add GoogleTest cpp_thread_tests")
-add_executable(cpp_thread_tests concurrency_tests.cpp exceptions_tests.cpp synchronized_queue_tests.cpp)
+add_executable(cpp_thread_tests concurrency_tests.cpp exceptions_tests.cpp )
 target_link_libraries(cpp_thread_tests GTest::GTest GTest::gtest_main cpp-pthread-static ${GCOV_LIB})
-
 add_test(NAME cpp_thread_tests COMMAND cpp_thread_tests)
+
+add_executable(synchronized_queue_tests synchronized_queue_tests.cpp)
+target_link_libraries(synchronized_queue_tests GTest::GTest GTest::gtest_main cpp-pthread-static ${GCOV_LIB})
+add_test(NAME synchronized_queue_tests COMMAND synchronized_queue_tests)
+

tests/concurrency_tests.cpp

@@ -18,8 +18,6 @@ TEST(concurrency, mutex) {
   try {
     pthread::lock_guard<pthread::mutex> lock(mutex);
     success = true;
-    // std::cout << "in critical section (mutex)" << std::endl;
-
   } catch ( std::exception &err) {
     std::cerr << "something went wrong: " << err.what() << std::endl;
   }catch ( ... ){
@@ -54,4 +52,74 @@ TEST(concurrency, read_write_lock) {
   }
 
   EXPECT_TRUE(success);
-}
+}
+
+TEST(concurrency, condition_variable_wait_for){
+    pthread::condition_variable condition;
+    pthread::mutex              mutex;
+    bool                        stop_waiting = true;
+
+    /* wait 1s for condition to be signaled. When returning from the wait_for method call, the mutex is locked.
+     *
+     * Therefore we expect, try_lock to throw an exception to signal that the mutex is already locked.
+     */
+    EXPECT_EQ(pthread::cv_status::timedout, condition.wait_for(mutex, 1*1000));
+    EXPECT_THROW(mutex.try_lock(), pthread::pthread_exception);
+    mutex.unlock(); // free to lock
+
+    {
+        pthread::lock_guard<pthread::mutex> lock{mutex};
+        EXPECT_EQ(pthread::cv_status::timedout, condition.wait_for(lock, 1 * 1000));
+    }
+
+    {
+        pthread::lock_guard<pthread::mutex> lock{mutex};
+        EXPECT_EQ(true, condition.wait_for(lock, 1 * 1000, [stop_waiting]{
+                    std::cout << "running lambda, stop_waiting : " << stop_waiting << std::endl ;
+                    return stop_waiting;
+                }
+            )
+        );
+    }
+
+
+    {
+        pthread::lock_guard<pthread::mutex> lock{mutex};
+        EXPECT_EQ(false, condition.wait_for(lock, 1 * 1000, [stop_waiting]{
+                std::cout << "running lambda, stop_waiting : " << stop_waiting << std::endl ;
+                return ! stop_waiting;
+                }
+            )
+        );
+    }
+}
+
+/* NOSONAR for later use
+   class test_thread: public pthread::abstract_thread{
+    public:
+        void run() noexcept override{
+            pthread::this_thread::sleep_for(5*1000);
+            std::cout << "thread is waiting for mutex" << std::endl;
+            pthread::lock_guard<pthread::mutex> lock(*_mutex);
+            std::cout << "thread got mutex" << std::endl;
+        }
+
+        test_thread( pthread::mutex *mutex): _mutex(mutex){
+
+        }
+    private:
+        pthread::mutex *_mutex;
+    };
+
+    pthread::mutex mutex;
+
+    test_thread thread{&mutex};
+    thread.start();
+    {
+        pthread::lock_guard<pthread::mutex> lock(mutex);
+        pthread::this_thread::sleep_for(10*1000);
+    }
+
+    thread.join();
+
+ */