From a092dd441e28227a7a078cc0c1548e8be8d8a43f Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Wed, 25 Apr 2018 16:46:41 +0900 Subject: [PATCH] utest: check the tbm_error_e for the surface_queue tests Change-Id: Ib7983219c813dbbb5fe3e82fd78e909856b9b629 --- utests/ut_tbm_surface_queue.cpp | 594 +++++++++++++++++--------------- 1 file changed, 310 insertions(+), 284 deletions(-) diff --git a/utests/ut_tbm_surface_queue.cpp b/utests/ut_tbm_surface_queue.cpp index 16c7ee2..0a664cd 100644 --- 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 -- 2.34.1