utest: check the tbm_error_e for the surface_queue tests

Change-Id: Ib7983219c813dbbb5fe3e82fd78e909856b9b629

diff --git a/utests/ut_tbm_surface_queue.cpp b/utests/ut_tbm_surface_queue.cpp
index 16c7ee259a02c576e72c3498e7087934d4bb7662..0a664cd51e44ee7177a81b1f3995921fd5772fab 100644 (file)
--- a/utests/ut_tbm_surface_queue.cpp
+++ b/utests/ut_tbm_surface_queue.cpp
@@ -57,7 +57,7 @@ void TBMSurfaceQueue::SetUp()
        TBMBufmgr::SetUp();
 
        result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
-       ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
+       EXPECT_STREQ(tbm_error_str(TBM_ERROR_NONE), tbm_error_str(result));
 
        for (uint32_t i = 0; i < num_formats; i++)
                if (formats[i] == TBM_FORMAT_ARGB8888)
@@ -69,10 +69,11 @@ void TBMSurfaceQueue::SetUp()
        width = 720;
        height = 1024;
        alien_surface = tbm_surface_create(width, height, format);
-       ASSERT_NE((tbm_surface_h)NULL, alien_surface);
+       EXPECT_NE((tbm_surface_h)NULL, alien_surface);
 
        queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
-       ASSERT_NE((tbm_surface_queue_h)NULL, queue);
+       EXPECT_NE((tbm_surface_queue_h)NULL, queue);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 void TBMSurfaceQueue::TearDown()
@@ -124,9 +125,11 @@ TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
        tbm_surface_queue_h queue1 = NULL;
 
        queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, queue1);
+       EXPECT_NE(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_surface_queue_destroy(queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_surface_queue_h tbm_surface_queue_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
@@ -136,16 +139,20 @@ TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
        tbm_surface_queue_h queue1 = NULL;
 
        queue1 = tbm_surface_queue_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1); // Expected Value: NULL
+       EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_surface_queue_h tbm_surface_queue_sequence_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
@@ -155,16 +162,20 @@ TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
        tbm_surface_queue_h queue1 = NULL;
 
        queue1 = tbm_surface_queue_sequence_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1); // Expected Value: NULL
+       EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, queue1);
+       EXPECT_EQ(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
@@ -172,9 +183,11 @@ TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
        tbm_surface_queue_h queue1 = NULL;
 
        queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, queue1);
+       EXPECT_NE(nullptr, queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_surface_queue_destroy(queue1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 
@@ -182,13 +195,16 @@ TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
 TEST_F(TBMSurfaceQueue, DestroyNULL)
 {
        tbm_surface_queue_destroy(NULL);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, DestroyTwice)
 {
        tbm_surface_queue_destroy(queue);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_surface_queue_destroy(queue);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        /* to prevent destroy in TearDown */
        queue = NULL;
@@ -199,12 +215,11 @@ TEST_F(TBMSurfaceQueue, DestroyTwice)
 TEST_F(TBMSurfaceQueue, DequeueFailNull)
 {
        ASSERT_EXIT({
-
                result = tbm_surface_queue_dequeue(NULL, &surface);
-               ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
                result = tbm_surface_queue_dequeue(queue, NULL);
-               ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
                exit(0);
        }, ::testing::ExitedWithCode(0), "");
@@ -213,7 +228,7 @@ TEST_F(TBMSurfaceQueue, DequeueFailNull)
 TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
 {
        result = tbm_surface_queue_dequeue(invalid_queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, DequeueSuccess)
@@ -221,13 +236,13 @@ TEST_F(TBMSurfaceQueue, DequeueSuccess)
        /* do dequeue three times */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-               ASSERT_NE((tbm_surface_h)NULL, surface);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+               EXPECT_NE((tbm_surface_h)NULL, surface);
        }
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(nullptr, surface);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(nullptr, surface);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue,
@@ -238,10 +253,10 @@ TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
        int num;
 
        result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_get_surfaces(queue, surfaces, NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
@@ -250,7 +265,7 @@ TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
        int num;
 
        result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
@@ -260,27 +275,27 @@ TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
 
        /* test: empty queue*/
        result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(0, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(0, num);
 
        /* do dequeue three times */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-               ASSERT_NE(nullptr, surface);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+               EXPECT_NE(nullptr, surface);
        }
 
        /* test */
        result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
-               ASSERT_NE(nullptr, surfaces[i]);
+               EXPECT_NE(nullptr, surfaces[i]);
 
        /* test: get only number of surfaces */
        result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
@@ -288,29 +303,29 @@ TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
 TEST_F(TBMSurfaceQueue, CancelDequeueFailNull)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_dequeue(NULL, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_dequeue(queue, NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, CancelDequeueFailInvaildInput)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
 
        result = tbm_surface_queue_cancel_dequeue(invalid_queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_dequeue(queue, invalid_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_dequeue(queue, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
@@ -319,23 +334,23 @@ TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-               ASSERT_NE(nullptr, surface);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+               EXPECT_NE(nullptr, surface);
        }
 
        last_surface = surface;
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(nullptr, surface);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(nullptr, surface);
 
        /* test */
        result = tbm_surface_queue_cancel_dequeue(queue, last_surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(last_surface, surface);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(last_surface, surface);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_enqueue(
@@ -343,30 +358,30 @@ TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
 TEST_F(TBMSurfaceQueue, EnqueueFailNull)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_enqueue(NULL, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_enqueue(this->queue, NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_enqueue(invalid_queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_enqueue(queue, invalid_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_enqueue(queue, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, EnqueueSuccess)
@@ -376,27 +391,27 @@ TEST_F(TBMSurfaceQueue, EnqueueSuccess)
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 }
 
 TEST_F(TBMSurfaceQueue, EnqueueFailTwice)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_acquire(
@@ -405,22 +420,22 @@ TEST_F(TBMSurfaceQueue, AcquireFailNull)
 {
        /* test */
        result = tbm_surface_queue_acquire(NULL, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AcquireFailInvaildInput)
 {
        result = tbm_surface_queue_acquire(invalid_queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
 {
        result = tbm_surface_queue_acquire(invalid_queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AcquireSuccess)
@@ -431,22 +446,22 @@ TEST_F(TBMSurfaceQueue, AcquireSuccess)
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_acquire(queue, &acquired_surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-               ASSERT_EQ(surfaces[i], acquired_surface);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+               EXPECT_EQ(surfaces[i], acquired_surface);
        }
 
        /* test: acquire empty queue*/
        result = tbm_surface_queue_acquire(queue, &acquired_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(nullptr, acquired_surface);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(nullptr, acquired_surface);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
@@ -454,33 +469,33 @@ TEST_F(TBMSurfaceQueue, AcquireSuccess)
 TEST_F(TBMSurfaceQueue, CancelAcquireFailNull)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
 
        /* test */
        result = tbm_surface_queue_cancel_acquire(NULL, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_acquire(queue, NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, CancelAcquireFailInvaildInput)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_cancel_acquire(invalid_queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_acquire(queue, invalid_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_cancel_acquire(queue, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
@@ -489,29 +504,29 @@ TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_acquire(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        last_surface = surface;
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(nullptr, surface);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(nullptr, surface);
 
        /* test */
        result = tbm_surface_queue_cancel_acquire(queue, last_surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(last_surface, surface);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(last_surface, surface);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_release(
@@ -519,38 +534,38 @@ TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
 TEST_F(TBMSurfaceQueue, ReleaseFailNull)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_release(NULL, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_release(this->queue, NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_release(invalid_queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_release(queue, invalid_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_release(queue, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, ReleaseSuccess)
@@ -559,17 +574,17 @@ TEST_F(TBMSurfaceQueue, ReleaseSuccess)
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_acquire(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_release(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 }
 
@@ -580,115 +595,127 @@ TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
        /* create a sequence queue instead of a default one*/
        tbm_surface_queue_destroy(queue);
        queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_acquire(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_release(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 }
 
 TEST_F(TBMSurfaceQueue, ReleaseFailTwice)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_release(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_release(queue, surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 /* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
 TEST_F(TBMSurfaceQueue, GetWidthFailNull)
 {
        int width = tbm_surface_queue_get_width(NULL);
-       ASSERT_EQ(0, width);
+       EXPECT_EQ(0, width);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetWidthFailInvalidInput)
 {
        int width = tbm_surface_queue_get_width(invalid_queue);
-       ASSERT_EQ(0, width);
+       EXPECT_EQ(0, width);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetWidthSuccess)
 {
        int width = tbm_surface_queue_get_width(queue);
-       ASSERT_EQ(this->width, width);
+       EXPECT_EQ(this->width, width);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
 TEST_F(TBMSurfaceQueue, GetHeightFailNull)
 {
        int height = tbm_surface_queue_get_height(NULL);
-       ASSERT_EQ(0, height);
+       EXPECT_EQ(0, height);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetHeightFailInvalidInput)
 {
        int height = tbm_surface_queue_get_height(invalid_queue);
-       ASSERT_EQ(0, height);
+       EXPECT_EQ(0, height);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetHeightSuccess)
 {
        int height = tbm_surface_queue_get_height(queue);
-       ASSERT_EQ(this->height, height);
+       EXPECT_EQ(this->height, height);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
 TEST_F(TBMSurfaceQueue, GetFormatFailNull)
 {
        int format = tbm_surface_queue_get_format(NULL);
-       ASSERT_EQ(0, format);
+       EXPECT_EQ(0, format);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetFormatFailInvalidInput)
 {
        int format = tbm_surface_queue_get_format(invalid_queue);
-       ASSERT_EQ(0, format);
+       EXPECT_EQ(0, format);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetFormatSuccess)
 {
        int format = tbm_surface_queue_get_format(queue);
-       ASSERT_EQ((int)this->format, format);
+       EXPECT_EQ((int)this->format, format);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
 TEST_F(TBMSurfaceQueue, GetSizeFailNull)
 {
        int q_size = tbm_surface_queue_get_size(NULL);
-       ASSERT_EQ(0, q_size);
+       EXPECT_EQ(0, q_size);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
 {
        int q_size = tbm_surface_queue_get_size(invalid_queue);
-       ASSERT_EQ(0, q_size);
+       EXPECT_EQ(0, q_size);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceQueue, GetSizeSuccess)
 {
        int q_size = tbm_surface_queue_get_size(queue);
-       ASSERT_EQ(UT_TBM_SURFACE_QUEUE_SIZE,  q_size);
+       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE,  q_size);
+       EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_reset(
@@ -696,28 +723,28 @@ TEST_F(TBMSurfaceQueue, GetSizeSuccess)
 TEST_F(TBMSurfaceQueue, ResetFailNull)
 {
        result = tbm_surface_queue_reset(NULL, width, height, format);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, ResetFailInvalidInput)
 {
        result = tbm_surface_queue_reset(invalid_queue, width, height, format);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_reset(invalid_queue, -1, height, format);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_reset(invalid_queue, width, -1, format);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_reset(invalid_queue, width, height, 0);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, ResetSuccessEmptyQueue)
 {
        result = tbm_surface_queue_reset(queue, width-10, height-10, format);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
@@ -726,11 +753,11 @@ TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
 
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_reset(queue, width, height, format);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
@@ -742,11 +769,11 @@ TEST_F(TBMSurfaceQueue, ResetSuccess)
 
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
@@ -762,11 +789,11 @@ TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
        ASSERT_TRUE(queue != NULL);
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
@@ -777,16 +804,16 @@ TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
 TEST_F(TBMSurfaceQueue, SetSizeFailNull)
 {
        result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
 {
        result = tbm_surface_queue_set_size(invalid_queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_set_size(NULL, 0, 0);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
@@ -794,16 +821,16 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
        tbm_surface_h surface = NULL;
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*test: */
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 
        /*test: with flush*/
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 1);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 }
 
@@ -812,16 +839,16 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
        tbm_surface_h surface = NULL;
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*test: */
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+1, 0);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 
        /*test: with flush*/
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+2, 1);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 }
 
@@ -830,16 +857,16 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
        tbm_surface_h surface = NULL;
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*test: */
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-1, 0);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
 
        /*test: with flush*/
        result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-2, 1);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
 }
 
@@ -847,13 +874,13 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
 TEST_F(TBMSurfaceQueue, FlushFailNull)
 {
        result = tbm_surface_queue_flush(NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
 {
        result = tbm_surface_queue_flush(invalid_queue);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, FlushSuccess)
@@ -862,19 +889,19 @@ TEST_F(TBMSurfaceQueue, FlushSuccess)
 
        /*test: flushing not initialized queue*/
        result = tbm_surface_queue_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
 
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        result = tbm_surface_queue_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
@@ -885,13 +912,13 @@ TEST_F(TBMSurfaceQueue, FlushSuccess)
 TEST_F(TBMSurfaceQueue, FreeFlushFailNull)
 {
        result = tbm_surface_queue_free_flush(NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
 {
        result = tbm_surface_queue_free_flush(invalid_queue);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
@@ -900,20 +927,20 @@ TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
 
        /*test: flushing not initialized queue*/
        result = tbm_surface_queue_free_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
 
        /* init queue */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
        result = tbm_surface_queue_free_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* extra check */
        for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
@@ -925,33 +952,33 @@ TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
 TEST_F(TBMSurfaceQueue, AddResetCbFailNull)
 {
        result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_reset_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddResetCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
        cb_data = 0;
        result = tbm_surface_queue_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -960,7 +987,7 @@ TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveResetCbFailNull)
 {
        result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
@@ -971,12 +998,12 @@ TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
 
        /* test */
        result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
        cb_data = 0;
        result = tbm_surface_queue_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 0);
 }
 
@@ -988,20 +1015,20 @@ TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
 
        /* test: invalid queue*/
        result = tbm_surface_queue_remove_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test: invalid data */
        result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, NULL);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test: invalid cb function */
        result = tbm_surface_queue_remove_reset_cb(queue, (tbm_surface_queue_notify_cb)1, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
        cb_data = 0;
        result = tbm_surface_queue_flush(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1009,24 +1036,24 @@ TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
 TEST_F(TBMSurfaceQueue, NotifyResetFailNull)
 {
        result = tbm_surface_queue_notify_reset(NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, NotifyResetFailInvalidInput)
 {
        result = tbm_surface_queue_notify_reset(invalid_queue);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
 {
        result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        cb_data = 0;
        result = tbm_surface_queue_notify_reset(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1034,24 +1061,24 @@ TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailNull)
 {
        result = tbm_surface_queue_notify_dequeuable(NULL);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, NotifyDequeuableFailInvalidInput)
 {
        result = tbm_surface_queue_notify_dequeuable(invalid_queue);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, NotifyDequeuableCbSuccess)
 {
        /* test */
        result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_notify_dequeuable(queue);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1073,10 +1100,10 @@ TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
        /* test: dequeue all*/
        while (tbm_surface_queue_can_dequeue(queue, 0)) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                dq_count++;
        }
-       ASSERT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
+       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
 }
 
 TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
@@ -1084,7 +1111,7 @@ TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
        /*Dequeue all*/
        while (tbm_surface_queue_can_dequeue(queue, 0)) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
 
        /* test */
@@ -1114,18 +1141,18 @@ TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
 
        while (tbm_surface_queue_can_dequeue(queue, 0)) {
                result = tbm_surface_queue_dequeue(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surface);
        }
 
        /*Dequeue all*/
        while (tbm_surface_queue_can_acquire(queue, 0)) {
                result = tbm_surface_queue_acquire(queue, &surface);
-               ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                acq_count++;
        }
 
-       ASSERT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
+       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
@@ -1133,23 +1160,23 @@ TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
 TEST_F(TBMSurfaceQueue, AddDestroyCbFailNull)
 {
        result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_destroy_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDestroyCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
 {
        /* test */
        result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        tbm_surface_queue_destroy(queue);
@@ -1164,21 +1191,21 @@ TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailNull)
 {
        result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailInvalidInput)
 {
        result = tbm_surface_queue_remove_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
 {
        result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_remove_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        tbm_surface_queue_destroy(queue);
@@ -1193,34 +1220,34 @@ TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
 TEST_F(TBMSurfaceQueue, AddDequeuableCbFailNull)
 {
        result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_dequeuable_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDequeuableCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_release(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1230,34 +1257,34 @@ TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailNull)
 {
        result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailInvalidInput)
 {
        /* test: invalid queue */
        result = tbm_surface_queue_remove_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_remove_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_release(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 0);
 }
 
@@ -1266,27 +1293,27 @@ TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
 TEST_F(TBMSurfaceQueue, AddDequeueCbFailNull)
 {
        result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_dequeue_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDequeueCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
 {
        /* test */
        result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1295,33 +1322,33 @@ TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailNull)
 {
        result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailInvalidInput)
 {
        /* test: invalid queue */
        result = tbm_surface_queue_remove_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
 {
        /* test */
        result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 
        result = tbm_surface_queue_remove_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 0);
 }
 
@@ -1330,23 +1357,23 @@ TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
 TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailNull)
 {
        result = tbm_surface_queue_add_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_can_dequeue_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
 {
        /* test */
        result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
@@ -1358,24 +1385,24 @@ TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailNull)
 {
        result = tbm_surface_queue_remove_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailInvalidInput)
 {
        /* test: invalid queue */
        result = tbm_surface_queue_remove_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
 {
        result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_remove_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
@@ -1387,16 +1414,16 @@ TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
 TEST_F(TBMSurfaceQueue, AddAcquirableCbFailNull)
 {
        result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_acquirable_cb(queue, NULL, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddAcquirableCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
@@ -1405,11 +1432,11 @@ TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
 
        /* test */
        result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 1);
 }
 
@@ -1418,30 +1445,30 @@ TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailNull)
 {
        result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailInvalidInput)
 {
        /* test: invalid queue */
        result = tbm_surface_queue_remove_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_remove_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        cb_data = 0;
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(cb_data == 0);
 }
 
@@ -1450,16 +1477,16 @@ TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
 TEST_F(TBMSurfaceQueue, AddTraceCbFailNull)
 {
        result = tbm_surface_queue_add_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_add_trace_cb(queue, NULL, &trace_cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddTraceCbFailInvalidInput)
 {
        result = tbm_surface_queue_add_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
@@ -1468,32 +1495,32 @@ TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
 
        /* test */
        result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
 
        result = tbm_surface_queue_cancel_dequeue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE);
 
        result = tbm_surface_queue_dequeue(queue, &surface);
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
 
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
 
        result = tbm_surface_queue_cancel_acquire(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE);
 
        result = tbm_surface_queue_acquire(queue, &surface);
        result = tbm_surface_queue_release(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_RELEASE);
 }
 
@@ -1502,14 +1529,14 @@ TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
 TEST_F(TBMSurfaceQueue, RemoveTraceCbFailNull)
 {
        result = tbm_surface_queue_remove_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveTraceCbFailInvalidInput)
 {
        /* test: invalid queue */
        result = tbm_surface_queue_remove_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
@@ -1517,14 +1544,14 @@ TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
        trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
 
        result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test */
        result = tbm_surface_queue_remove_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_NONE);
 }
 
@@ -1534,26 +1561,26 @@ TEST_F(TBMSurfaceQueue, SetAllocCbFailNull)
 {
        result = tbm_surface_queue_set_alloc_cb(NULL, tbm_surface_alloc_cb_handler,
                        tbm_surface_free_cb_handler, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetAllocCbFailInvalidInput)
 {
        result = tbm_surface_queue_set_alloc_cb(invalid_queue, tbm_surface_alloc_cb_handler,
                        tbm_surface_free_cb_handler, alien_surface);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetAllocCbSuccess)
 {
        result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler,
                        tbm_surface_free_cb_handler, alien_surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test: allocate */
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(alien_surface, surface);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(alien_surface, surface);
 
        /* test:  alien_surface has to be deleted*/
        tbm_surface_queue_destroy(queue);
@@ -1571,10 +1598,10 @@ TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailNull)
        ASSERT_EXIT({
 
                result = tbm_surface_queue_get_trace_surface_num(NULL, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
-               ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
                result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, NULL);
-               ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+               EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
                exit(0);
        }, ::testing::ExitedWithCode(0), "");
@@ -1586,7 +1613,7 @@ TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailInvalidInput)
        int num = 0;
 
        result = tbm_surface_queue_get_trace_surface_num(invalid_queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
@@ -1614,75 +1641,74 @@ TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
 
        /* test */
        result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(0, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(0, num);
 
        result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(1, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(1, num);
 
        result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ENQUEUE, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(1, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(1, num);
 
        result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ACQUIRE, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(1, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(1, num);
 
        result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_RELEASE, &num);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-       ASSERT_EQ(1, num);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+       EXPECT_EQ(1, num);
 }
 /* tbm_surface_queue_error_e tbm_surface_queue_set_modes(
                        tbm_surface_queue_h surface_queue, int modes); */
 TEST_F(TBMSurfaceQueue, SetModesFailNull)
 {
        result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetModesFailInvalidInput)
 {
        result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetModesSuccess)
 {
        result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 /* tbm_surface_queue_set_sync_count() */
 TEST_F(TBMSurfaceQueue, SetSyncCountFailNull)
 {
        result = tbm_surface_queue_set_sync_count(NULL, 1);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetSyncCountFailInvalidInput)
 {
        result = tbm_surface_queue_set_sync_count(invalid_queue, 1);
-       ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
 
 TEST_F(TBMSurfaceQueue, SetSyncCountSuccess)
 {
        result = tbm_surface_queue_dequeue(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test: map after enqueue */
        result = tbm_surface_queue_set_sync_count(queue, 0);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_enqueue(queue, surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        /* test: map after acquire */
        result = tbm_surface_queue_set_sync_count(queue, 0);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_acquire(queue, &surface);
-       ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result);
-
+       EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 }
\ No newline at end of file