Working unittests

Author: Tharazi97

UNITTESTS/events/equeue/test_equeue.cpp

@@ -26,6 +26,8 @@
 #define DISPATCH_INFINITE -1
 #define ITERATION_TIMES 10
 
+extern unsigned int global_time;
+
 class TestEqueue : public testing::Test {
     virtual void SetUp()
     {
@@ -48,6 +50,7 @@ static void simple_func(void *p)
 
 static void sloth_func(void *p)
 {
+    global_time += 10;
     usleep(10000);
     (*(reinterpret_cast<uint8_t *>(p)))++;
 }
@@ -122,7 +125,7 @@ static void nest_func(void *p)
 {
     struct nest *nst = reinterpret_cast<struct nest *>(p);
     equeue_call(nst->q, nst->cb, nst->data);
-
+    global_time += 10;
     usleep(10000);
 }
 
@@ -133,6 +136,14 @@ static void *multithread_thread(void *p)
     return 0;
 }
 
+static void multithread_func(void *p)
+{
+    if ((*(reinterpret_cast<uint8_t *>(p))) < 200) {
+        (*(reinterpret_cast<uint8_t *>(p)))++;
+    }
+    usleep(10);
+}
+
 static void background_func(void *p, int ms)
 {
     *(reinterpret_cast<int *>(p)) = ms;
@@ -160,6 +171,7 @@ static void simple_breaker(void *p)
 {
     struct count_and_queue *caq = reinterpret_cast<struct count_and_queue *>(p);
     equeue_break(caq->q);
+    global_time += 10;
     usleep(10000);
     caq->p++;
 }
@@ -223,7 +235,7 @@ TEST_F(TestEqueue, test_equeue_simple_call_in)
  *  Then function passed by equeue_call_every is executed properly.
  */
 
-TEST_F(TestEqueue, test_equeue_simple_call_every) // not working
+TEST_F(TestEqueue, test_equeue_simple_call_every)
 {
     equeue_t q;
     int err = equeue_create(&q, TEST_EQUEUE_SIZE);
@@ -548,7 +560,7 @@ TEST_F(TestEqueue, test_equeue_break_no_windup)
  *  Then event is executed (dispatch time/period) times.
  */
 
-TEST_F(TestEqueue, test_equeue_period) // not working
+TEST_F(TestEqueue, test_equeue_period)
 {
     equeue_t q;
     int err = equeue_create(&q, TEST_EQUEUE_SIZE);
@@ -569,7 +581,7 @@ TEST_F(TestEqueue, test_equeue_period) // not working
  *  When nested function is added to enqueue.
  *  Then it is executed in the next dispatch, or after execution of "mother" function.
  */
-TEST_F(TestEqueue, test_equeue_nested) // not working
+TEST_F(TestEqueue, test_equeue_nested)
 {
     equeue_t q;
     int err = equeue_create(&q, TEST_EQUEUE_SIZE);
@@ -645,14 +657,14 @@ TEST_F(TestEqueue, test_equeue_sloth)
  *  When equeue starts dispatching in one thread.
  *  Then it can be stopped from another thread via equeue_break.
  */
-TEST_F(TestEqueue, test_equeue_multithread) // not working
+TEST_F(TestEqueue, test_equeue_multithread)
 {
     equeue_t q;
     int err = equeue_create(&q, TEST_EQUEUE_SIZE);
     ASSERT_EQ(0, err);
 
     uint8_t touched = 0;
-    equeue_call_every(&q, 1, simple_func, &touched);
+    equeue_call_every(&q, 1, multithread_func, &touched);
 
     pthread_t thread;
     err = pthread_create(&thread, 0, multithread_thread, &q);
@@ -929,7 +941,7 @@ TEST_F(TestEqueue, test_equeue_multithreaded_barrage)
  *  When equeue break request flag is called but equeue stops dispatching because of timeout.
  *  Then next equeue dispatch is not stopped.
  */
-TEST_F(TestEqueue, test_equeue_break_request_cleared_on_timeout) // not working
+TEST_F(TestEqueue, test_equeue_break_request_cleared_on_timeout)
 {
     equeue_t q;
     int err = equeue_create(&q, TEST_EQUEUE_SIZE);

UNITTESTS/events/equeue/unittest.cmake

@@ -12,16 +12,11 @@ set(unittest-includes ${unittest-includes}
 
 set(unittest-sources
   ../events/equeue/equeue.c
-  ### comment on windows
-  ../events/equeue/equeue_posix.c
-  ###
 )
 
 set(unittest-test-sources
   events/equeue/test_equeue.cpp
-  ### uncomment on windows
-  # stubs/EqueuePosix_stub.c
-  ###
+  stubs/EqueuePosix_stub.c
 )
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -DEQUEUE_PLATFORM_POSIX")

UNITTESTS/stubs/EqueuePosix_stub.c

@@ -23,43 +23,91 @@
 #include <sys/time.h>
 #include <errno.h>
 
+unsigned int global_time = 0;
 
 // Tick operations
 void equeue_tick_init(void) {}
 
 unsigned equeue_tick(void)
 {
-    struct timeval tv;
-    gettimeofday(&tv, 0);
-    return (unsigned)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
+    return global_time;
 }
 
 
 // Mutex operations
 int equeue_mutex_create(equeue_mutex_t *m)
 {
-    return 0;
+    return pthread_mutex_init(m, 0);
 }
 
-void equeue_mutex_destroy(equeue_mutex_t *m) {}
+void equeue_mutex_destroy(equeue_mutex_t *m)
+{
+    pthread_mutex_destroy(m);
+}
 
-void equeue_mutex_lock(equeue_mutex_t *m) {}
+void equeue_mutex_lock(equeue_mutex_t *m)
+{
+    pthread_mutex_lock(m);
+}
+
+void equeue_mutex_unlock(equeue_mutex_t *m)
+{
+    pthread_mutex_unlock(m);
+}
 
-void equeue_mutex_unlock(equeue_mutex_t *m) {}
 
 // Semaphore operations
 int equeue_sema_create(equeue_sema_t *s)
 {
+    int err = pthread_mutex_init(&s->mutex, 0);
+    if (err) {
+        return err;
+    }
+
+    err = pthread_cond_init(&s->cond, 0);
+    if (err) {
+        return err;
+    }
+
+    s->signal = false;
     return 0;
 }
 
-void equeue_sema_destroy(equeue_sema_t *s) {}
+void equeue_sema_destroy(equeue_sema_t *s)
+{
+    pthread_cond_destroy(&s->cond);
+    pthread_mutex_destroy(&s->mutex);
+}
 
-void equeue_sema_signal(equeue_sema_t *s) {}
+void equeue_sema_signal(equeue_sema_t *s)
+{
+    pthread_mutex_lock(&s->mutex);
+    s->signal = true;
+    pthread_cond_signal(&s->cond);
+    pthread_mutex_unlock(&s->mutex);
+}
 
 bool equeue_sema_wait(equeue_sema_t *s, int ms)
 {
-    return false;
+    pthread_mutex_lock(&s->mutex);
+    if (!s->signal) {
+        if (ms < 0) {
+            pthread_cond_wait(&s->cond, &s->mutex);
+        } else {
+            for (int i = 0; i < ms; i++) {
+                global_time++;
+            }
+            if (ms == 0) {
+                global_time++;
+            }
+        }
+    }
+
+    bool signal = s->signal;
+    s->signal = false;
+    pthread_mutex_unlock(&s->mutex);
+
+    return signal;
 }
 
 #endif