Merge branch '175-174-cond_var-and-mutex-testing' into develop

Author: HerbertKoelman

include/pthread/condition_variable.hpp

@@ -64,10 +64,15 @@ namespace pthread {
          * @param mtx ralated mutex, which must be locked by the current thread.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_wait
          */
         void wait(mutex &mtx);
 
-        /** @see wai
+        /**  Wait for condition to be signaled within given time frame.
+         *
+         * The method uses the lock_guard's mutex to execute.
+         *
+         * @see #wait(mutex &)
          */
         void wait(lock_guard<pthread::mutex> lck);
 
@@ -82,10 +87,11 @@ namespace pthread {
          * The signature of the predicate function should be equivalent to the following: bool pred();
          *
          * @param mtx ralated mutex, which must be locked by the current thread.
-         * @param lambda run to check if condition was met.
+         * @param lambda code that checks if the condition is met (MUST return a boolean).
          * @return true if lmabda returned true.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_wait
          */
         template<class Lambda>
         bool wait(mutex &mtx, Lambda lambda);
@@ -101,10 +107,11 @@ namespace pthread {
          * The signature of the predicate function should be equivalent to the following: bool pred();
          *
          * @param lck ralated mutex lock_guard, which must be locked by the current thread.
-         * @param lambda run to check if condition was met.
+         * @param lambda code that checks if the condition is met (MUST return a boolean).
          * @return true if lmabda returned true.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_timedwait
          */
         template<class Lambda>
         bool wait(lock_guard<pthread::mutex> &lck, Lambda lambda);
@@ -125,10 +132,15 @@ namespace pthread {
          * @throw condition_variable_exception is thrown either if timeout calculation failed or mutex ownership was wrong.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_timedwait
          */
         cv_status wait_for(mutex &mtx, int millis);
 
-        /** @see #wait_for (mutex &, int)
+        /** Wait for condition to be signaled within given time frame.
+         *
+         * The method uses the lock_guard's mutex to execute.
+         *
+         * @see #wait_for (mutex &, int) NOSONAR this is not comment code
          */
         cv_status wait_for(lock_guard<pthread::mutex> &lck, int millis);
 
@@ -144,15 +156,16 @@ namespace pthread {
          *
          * @param mtx ralated mutex, which must be locked by the current thread.
          * @param millis milli seconds to wait for condition to be signaled.
-         * @param lambda run to check if condition was met.
+         * @param lambda code that checks if the condition is met (MUST return a boolean).
          * @return true if lmabda returned true.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_timedwait
          */
         template<class Lambda>
         bool wait_for(mutex &mtx, int millis, Lambda lambda);
 
-        /** NOSONAR Wait for condition to be signaled within a given time frame.
+        /** Wait for condition to be signaled within a given time frame.
          *
          * This method atomically release mutex and cause the calling thread to block; atomically here means "atomically with respect to
          * access by another thread to the mutex and then the condition variable". Call notify_one or notify_all to signal the condition.
@@ -168,33 +181,33 @@ namespace pthread {
          * @return true if lmabda returned true.
          * @see notify_one
          * @see notify_all
+         * @see pthread_cond_timedwait
          */
         template<class Lambda>
         bool wait_for(lock_guard<pthread::mutex> &lck, int millis, Lambda lambda);
 
-        /** Signal one waiting thread.
+        /** signal a condition.
+         *
+         * unblocks at least one of the threads that are blocked on the specified condition variable cond (if any threads are blocked on cond).
+         * > *WARN* the signature of this methode should be the same as `std::condition_variable::notify_one`, we decided to
+         * > throw an exception anyway, when the pthread function fails and not be strictly compliant.
          *
-         * The call unblocks at least one of the threads that are blocked on the specified condition variable cond (if any threads are blocked on cond).
+         * @throw condition_variable_exception if the call to pthread_cond_signal return value is different from 0 (zero)
+         * @see pthread_cond_signal
          */
-#if __cplusplus < 201103L
-        void notify_one () throw() ;
-#else
+        void notify_one() ;
 
-        void notify_one() noexcept;
-
-#endif
-
-        /** Signal all waiting threads.
+        /** broadcast a condition.
+         *
+         * unblocks all threads currently blocked on the specified condition variable cond.
+         *
+         * > *WARN* the signature of this methode should be the same as `std::condition_variable::notify_one`, we decided to
+         * > throw an exception anyway, when the pthread function fails and not be strictly compliant.
          *
-         * The call unblocks all threads currently blocked on the specified condition variable cond.
+         * @throw condition_variable_exception if the call to pthread_cond_broadcast return value is different from 0 (zero)
+         * @see pthread_cond_broadcast
          */
-#if __cplusplus < 201103L
-        void notify_all () throw() ;
-#else
-
-        void notify_all() noexcept;
-
-#endif
+        void notify_all();
 
         /**
          * not copy-assignable
@@ -203,7 +216,9 @@ namespace pthread {
 
         // constructor/destructor ------------------------------------------------
 
-        /** construct a new condition_variable (pthread_cond_init).
+        /** construct a new condition_variable.
+         *
+         * @see pthread_cond_init
          */
         condition_variable();
 
@@ -212,9 +227,10 @@ namespace pthread {
          */
         condition_variable(const condition_variable &) = delete;
 
-        /** destroy a condition_variable (pthread_cond_destroy)
+        /** destroy a condition_variable.
          *
          * @throw condition_variable_exception if conditional variable failed to be destroyed (pthread_cond_destroy != 0)
+         * @see pthread_cond_destroy
          */
         ~condition_variable() ;
 

include/pthread/mutex.hpp

@@ -46,13 +46,13 @@ namespace pthread {
         void 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.
+         * Identical to lock method except that if the mutex object is currently locked (by any thread, including the
+         * current thread), the call returns immediately.
          *
-         * @return
+         * @return true if the mutex is locked, false is returned if the lock is held by some other thread.
          * @throw mutex_exception if error conditions preventing this method to succeed.
          * @see lock
+         * @see unlock
          */
         bool try_lock();
 

include/pthread/thread.hpp

@@ -150,7 +150,7 @@ namespace pthread {
          *
          * @return the stack size in bytes.
          */
-         size_t stact_size();
+         size_t stack_size();
 
         /** copy operator is flagged deleted,  copying doesn't make sense
          */
@@ -264,8 +264,7 @@ namespace pthread {
         /** @return true if this thread can be joined.
          */
         bool joinable() const;
-
-
+        
         /** not copy-assignable */
         void operator=(const abstract_thread &) = delete;
 

src/condition_variable.cpp

@@ -45,21 +45,18 @@ namespace pthread {
     return status;
   }
 
-#if __cplusplus < 201103L
-  void condition_variable::notify_one() throw() {
-#else
-  void condition_variable::notify_one() noexcept {
-#endif
-    pthread_cond_signal ( &_condition );
+  void condition_variable::notify_one(){
+    int rc = pthread_cond_signal ( &_condition );
+    if ( rc != 0 ){
+      throw condition_variable_exception{"notify_all failed.", rc};
+    }
   }
 
-#if __cplusplus < 201103L
-  void condition_variable::notify_all () throw(){
-#else
-  void condition_variable::notify_all () noexcept{
-#endif
-    pthread_cond_broadcast ( &_condition );
-
+  void condition_variable::notify_all () {
+    int rc = pthread_cond_broadcast ( &_condition );
+    if ( rc != 0 ){
+        throw condition_variable_exception{"notify_all failed.", rc};
+    }
   }
 
   void condition_variable::milliseconds(int millis){

src/mutex.cpp

@@ -34,7 +34,9 @@ namespace pthread {
 
         auto rc = pthread_mutex_trylock(&_mutex);
         if (rc == 0) {
-            status = true;
+            status = true; // mutex is locked now
+        }else if ( rc == EBUSY){
+            status = false ; // mutex is held by some other thread
         } else {
             throw mutex_exception("pthread_mutex_trylock failed, already locked.", rc);
         }

src/thread.cpp

@@ -148,7 +148,7 @@ namespace pthread {
         _attr_ptr = &_attr; // pthread_attribute is always initialized
     }
 
-    size_t thread::stact_size() {
+    size_t thread::stack_size() {
         size_t size = -1;
         int rc = pthread_attr_getstacksize(_attr_ptr, &size);
         if ( rc != 0 ){
@@ -174,11 +174,13 @@ namespace pthread {
     }
 
     void abstract_thread::join() {
-        _thread->join();
+        if ( _thread != nullptr ){
+            _thread->join();
+        }
     };
 
     bool abstract_thread::joinable() const {
-        return _thread != 0 && _thread->joinable();
+        return _thread != nullptr && _thread->joinable();
     };
 
 #if __cplusplus < 201103L

tests/abstract_thread_tests.cpp

@@ -77,6 +77,8 @@ TEST(absttract_thread, self_join) {
 TEST(abstract_thread_group, start_auto_join) {
     pthread::thread_group threads{true};
 
+    EXPECT_TRUE(threads.destructor_joins_first());
+
     for (auto x = 10; x > 0; x--) {
         threads.add(new test_thread{});
     }