refs #174 #175 #177 #178 @4h

Author: HerbertKoelman

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

@@ -50,16 +50,21 @@ namespace pthread {
 #else
   void condition_variable::notify_one() noexcept {
 #endif
-    pthread_cond_signal ( &_condition );
+    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 );
-
+    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{});
     }

tests/concurrency_tests.cpp

@@ -10,52 +10,88 @@
 #include <memory>
 #include <ctime>
 
+class concurrency_test_runnable : public pthread::abstract_thread {
+public:
+
+    void run() noexcept override {
+        pthread::lock_guard<pthread::mutex> lock{*_mutex};
+        pthread::this_thread::sleep_for(2 * 1000);
+    }
+
+    concurrency_test_runnable(pthread::mutex *mutex) : _something{0}, _mutex{mutex} {
+        // intentional
+    }
+
+    void set_something(const int something){
+        pthread::lock_guard<pthread::write_lock> lock(_properties_accessor_lock);
+        _something = something;
+    }
+
+    const int something(){
+        pthread::lock_guard<pthread::read_lock> lock(_properties_accessor_lock);
+        return _something;
+    }
+
+private:
+
+    int _something;
+    pthread::mutex *_mutex;
+    pthread::read_write_lock _properties_accessor_lock;
+};
+
 TEST(concurrency, mutex) {
 
-  bool success = false;
+    bool success = false;
 
-  pthread::mutex mutex;
-  try {
-    pthread::lock_guard<pthread::mutex> lock(mutex);
-    success = true;
-  } catch ( std::exception &err) {
-    std::cerr << "something went wrong: " << err.what() << std::endl;
-  }catch ( ... ){
-    std::cerr << "something went wrong, unexpected exception catched."<< std::endl;
-  }
+    pthread::mutex mutex;
+    concurrency_test_runnable mtr{&mutex};
+    mtr.start();
 
-  EXPECT_TRUE(success);
+    pthread::this_thread::sleep_for(500); // just to let time to startup the thread.
+
+    EXPECT_FALSE(mutex.try_lock()); // return false, because the test thread has already locked the mutex
+    EXPECT_NO_THROW(pthread::lock_guard<pthread::mutex> lock(mutex));
+    EXPECT_TRUE(mutex.try_lock()); // the test thread has ended and the lock can be aquired again
+
+    mtr.join();
 }
 
 TEST(concurrency, read_write_lock) {
-  bool success = false ;
+    bool success = false;
+
+    try {
+        pthread::mutex mutex;
 
-  try {
+        concurrency_test_runnable thread{&mutex};
+        thread.start();
 
-    pthread::read_write_lock _rwlock;
+        thread.set_something(1000);
+        EXPECT_EQ(1000, thread.something());
 
-    {
-      pthread::lock_guard<pthread::read_lock> lock(_rwlock);
+        pthread::read_write_lock _rwlock;
 
-      // std::cout << "read locked" << std::endl;
-    }
+        {
+            pthread::lock_guard<pthread::read_lock> lock(_rwlock);
 
-    {
-      pthread::lock_guard<pthread::write_lock> lock(_rwlock);
-      // std::cout << "write locked" << std::endl;
-    }
+        }
 
-    success = true;
+        {
+            pthread::lock_guard<pthread::write_lock> lock(_rwlock);
+        }
 
-  }catch (std::exception &err ){
-    std::cerr << __FILE__ << "(at:" << __LINE__ << ")" << err.what() << std::endl;
-  }
+        thread.join();
 
-  EXPECT_TRUE(success);
+        success = true;
+
+    } catch (std::exception &err) {
+        std::cerr << __FILE__ << "(at:" << __LINE__ << ")" << err.what() << std::endl;
+    }
+
+    EXPECT_TRUE(success);
 }
 
 TEST(concurrency, try_read_write_lock) {
-    bool success = false ;
+    bool success = false;
 
     try {
 
@@ -66,50 +102,54 @@ TEST(concurrency, try_read_write_lock) {
 
         success = true;
 
-    }catch ( const std::exception &err ){
+    } catch (const std::exception &err) {
         std::cerr << err.what() << std::endl << std::flush;
     }
 
     EXPECT_TRUE(success);
 }
 
-TEST(concurrency, condition_variable_wait_for){
+TEST(concurrency, condition_variable_wait_for) {
     pthread::condition_variable condition;
-    pthread::mutex              mutex;
-    bool                        stop_waiting = true;
+    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);
+    EXPECT_EQ(pthread::cv_status::timedout, condition.wait_for(mutex, 1 * 1000));
+    EXPECT_FALSE(mutex.try_lock());
     mutex.unlock(); // free to lock
 
+    EXPECT_NO_THROW(condition.notify_all());
+    EXPECT_NO_THROW(condition.notify_one());
+
     {
         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;
-                }
-            )
+        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;
-                }
-            )
+        EXPECT_EQ(false,
+                condition.wait_for(lock, 1 * 1000, [stop_waiting] {
+                                                std::cout << "running lambda, stop_waiting : " << stop_waiting << std::endl;
+                                                return !stop_waiting;
+                                            })
         );
+
     }
 }
 

tests/exceptions_tests.cpp

@@ -44,7 +44,7 @@ TEST(exceptions, condition_variable_exception) {
 
     try {
         throw pthread::condition_variable_exception();
-    } catch (pthread::pthread_exception &ex) {
+    } catch (pthread::condition_variable_exception &ex) {
         EXPECT_STREQ("conditional_variable_exception", ex.what());
         EXPECT_EQ(0, ex.error_number());
     }
@@ -82,6 +82,8 @@ TEST(exceptions, timeout_exception) {
     }
 }
 
+// pthread::util exception -----------------------------------------
+
 TEST(exceptions, util_queue_exception) {
     std::string expecting = "Condition variable exception test. ";
     expecting += strerror(-1);
@@ -95,15 +97,15 @@ TEST(exceptions, util_queue_exception) {
 TEST(exceptions, util_queue_full_exception) {
     try {
         throw pthread::util::queue_full();
-    } catch (std::exception &ex) {
+    } catch (pthread::util::queue_exception &ex) {
         EXPECT_STREQ("synchronized_queue full.", ex.what());
     }
 }
 
 TEST(exceptions, util_queue_access_timeout_exception) {
     try {
         throw pthread::util::queue_timeout();
-    } catch (std::exception &ex) {
+    } catch (pthread::util::queue_exception &ex) {
         EXPECT_STREQ("synchronized_queue get/put timed out.", ex.what());
     }
 }

tests/thread_tests.cpp

@@ -11,6 +11,7 @@
 #include <string>
 #include <memory>
 #include <ctime>
+#include <chrono>
 
 class test_runnable : public pthread::runnable {
 public:
@@ -92,7 +93,7 @@ TEST(thread, stack_size) {
     // This should work
     std::unique_ptr<test_runnable> tr{new test_runnable{"status test"}};
     pthread::thread t{*tr, initialized_stack_size};
-    EXPECT_EQ(t.stact_size(), initialized_stack_size);
+    EXPECT_EQ(t.stack_size(), initialized_stack_size);
     t.join();
 
     // This should NOT work
@@ -129,6 +130,7 @@ TEST(thread, thread_constructor) {
         pthread::thread t2{*tr};
         EXPECT_EQ(t2.status(), pthread::thread_status::a_thread);
         t2.join();
+
     } catch (std::exception &err) {
         std::cerr << "thread_constructor test failed. " << err.what() << std::endl;
     }
@@ -151,4 +153,23 @@ TEST(thread, move_operator) {
 
     T2.join();
     EXPECT_NO_THROW(T2.join());
+
+    pthread::thread T3;
+    T3 = std::move(T2);
+    EXPECT_EQ(T3.status(), pthread::thread_status::not_a_thread);
+
 }
+
+TEST(thread, this_thread_sleep) {
+    auto start = std::chrono::steady_clock::now();
+    pthread::this_thread::sleep_for(500);
+    pthread::this_thread::sleep_for(1500);
+    pthread::this_thread::sleep_for(1000);
+    pthread::this_thread::sleep_for(0);
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(start - std::chrono::steady_clock::now()).count();
+    EXPECT_GT(2.3, duration);
+}
+
+TEST(thread, this_thread_get_id) {
+    auto id = pthread::this_thread::get_id();
+}