From befc775b6730e1744f7c031fe64cbeca2d38e877 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Tue, 20 Feb 2018 17:36:03 +0900 Subject: [PATCH] utest: rename UtSurfaceQueue to SurfaceQueueTest Change-Id: I5809f4207959451db722ca73c459d216c24bcff0 --- utests/ut.cpp | 18 +-- utests/ut.h | 2 +- utests/ut_tbm_surface_queue.cpp | 242 ++++++++++++++++++++-------------------- 3 files changed, 131 insertions(+), 131 deletions(-) diff --git a/utests/ut.cpp b/utests/ut.cpp index bc207de..a52ce6e 100644 --- a/utests/ut.cpp +++ b/utests/ut.cpp @@ -106,13 +106,13 @@ void SurfaceTest::TearDown() } -int UtSurfaceQueue::width = 720; -int UtSurfaceQueue::height = 1024; -int UtSurfaceQueue::format; -uint32_t UtSurfaceQueue::num_formats; -tbm_format *UtSurfaceQueue::formats; +int SurfaceQueueTest::width = 720; +int SurfaceQueueTest::height = 1024; +int SurfaceQueueTest::format; +uint32_t SurfaceQueueTest::num_formats; +tbm_format *SurfaceQueueTest::formats; -void UtSurfaceQueue::SetUpTestCase() +void SurfaceQueueTest::SetUpTestCase() { tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -130,13 +130,13 @@ void UtSurfaceQueue::SetUpTestCase() format = formats[0]; } -void UtSurfaceQueue::TearDownTestCase() +void SurfaceQueueTest::TearDownTestCase() { if (formats) free(formats); } -void UtSurfaceQueue::SetUp() +void SurfaceQueueTest::SetUp() { alien_surface = tbm_surface_create(width, height, format); ASSERT_NE((tbm_surface_h)NULL, alien_surface); @@ -145,7 +145,7 @@ void UtSurfaceQueue::SetUp() ASSERT_NE((tbm_surface_queue_h)NULL, queue); } -void UtSurfaceQueue::TearDown() +void SurfaceQueueTest::TearDown() { if (alien_surface) tbm_surface_destroy(alien_surface); diff --git a/utests/ut.h b/utests/ut.h index 09f6f32..4948936 100644 --- a/utests/ut.h +++ b/utests/ut.h @@ -73,7 +73,7 @@ typedef SurfaceTest UtSurfaceInternal; #define QUEUE_SIZE 3 -class UtSurfaceQueue : public ::testing::Test +class SurfaceQueueTest : public ::testing::Test { protected: static void SetUpTestCase(); diff --git a/utests/ut_tbm_surface_queue.cpp b/utests/ut_tbm_surface_queue.cpp index 8673684..c8b7472 100644 --- a/utests/ut_tbm_surface_queue.cpp +++ b/utests/ut_tbm_surface_queue.cpp @@ -116,12 +116,12 @@ TEST(UtSurfaceQueueCreate, SequenceCreateSuccess) /* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, DestroyNULL) +TEST_F(SurfaceQueueTest, DestroyNULL) { tbm_surface_queue_destroy(NULL); } -TEST_F(UtSurfaceQueue, DestroyTwice) +TEST_F(SurfaceQueueTest, DestroyTwice) { tbm_surface_queue_destroy(queue); @@ -133,7 +133,7 @@ TEST_F(UtSurfaceQueue, DestroyTwice) /* tbm_surface_queue_error_e tbm_surface_queue_dequeue( tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */ -TEST_F(UtSurfaceQueue, DequeueFailNull) +TEST_F(SurfaceQueueTest, DequeueFailNull) { ASSERT_EXIT({ @@ -147,13 +147,13 @@ TEST_F(UtSurfaceQueue, DequeueFailNull) }, ::testing::ExitedWithCode(0), ""); } -TEST_F(UtSurfaceQueue, DequeueFailInvaildInput) +TEST_F(SurfaceQueueTest, DequeueFailInvaildInput) { result = tbm_surface_queue_dequeue(invalid_queue, &surface); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, DequeueSuccess) +TEST_F(SurfaceQueueTest, DequeueSuccess) { /* do dequeue three times */ for (int i = 0; i < QUEUE_SIZE; i++) { @@ -169,7 +169,7 @@ TEST_F(UtSurfaceQueue, DequeueSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue, tbm_surface_h *surfaces, int *num); */ -TEST_F(UtSurfaceQueue, GetSurfacesFailNull) +TEST_F(SurfaceQueueTest, GetSurfacesFailNull) { tbm_surface_h surfaces[QUEUE_SIZE]; int num; @@ -181,7 +181,7 @@ TEST_F(UtSurfaceQueue, GetSurfacesFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, GetSurfacesFailInvaildInput) +TEST_F(SurfaceQueueTest, GetSurfacesFailInvaildInput) { tbm_surface_h surfaces[QUEUE_SIZE]; int num; @@ -190,7 +190,7 @@ TEST_F(UtSurfaceQueue, GetSurfacesFailInvaildInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, GetSurfacesSuccess) +TEST_F(SurfaceQueueTest, GetSurfacesSuccess) { tbm_surface_h surfaces[QUEUE_SIZE]; int num = 0; @@ -222,7 +222,7 @@ TEST_F(UtSurfaceQueue, GetSurfacesSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue( tbm_surface_queue_h surface_queue, tbm_surface_h surface); */ -TEST_F(UtSurfaceQueue, CancelDequeueFailNull) +TEST_F(SurfaceQueueTest, CancelDequeueFailNull) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -234,7 +234,7 @@ TEST_F(UtSurfaceQueue, CancelDequeueFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, CancelDequeueFailInvaildInput) +TEST_F(SurfaceQueueTest, CancelDequeueFailInvaildInput) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -250,7 +250,7 @@ TEST_F(UtSurfaceQueue, CancelDequeueFailInvaildInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, CancelDequeueSuccess) +TEST_F(SurfaceQueueTest, CancelDequeueSuccess) { tbm_surface_h last_surface = NULL; @@ -277,7 +277,7 @@ TEST_F(UtSurfaceQueue, CancelDequeueSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_enqueue( tbm_surface_queue_h surface_queue, tbm_surface_h surface); */ -TEST_F(UtSurfaceQueue, EnqueueFailNull) +TEST_F(SurfaceQueueTest, EnqueueFailNull) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -290,7 +290,7 @@ TEST_F(UtSurfaceQueue, EnqueueFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, EnqueueFailInvaildInput) +TEST_F(SurfaceQueueTest, EnqueueFailInvaildInput) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -306,7 +306,7 @@ TEST_F(UtSurfaceQueue, EnqueueFailInvaildInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, EnqueueSuccess) +TEST_F(SurfaceQueueTest, EnqueueSuccess) { tbm_surface_h surfaces[QUEUE_SIZE] = { NULL }; @@ -323,7 +323,7 @@ TEST_F(UtSurfaceQueue, EnqueueSuccess) } } -TEST_F(UtSurfaceQueue, EnqueueFailTwice) +TEST_F(SurfaceQueueTest, EnqueueFailTwice) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -338,7 +338,7 @@ TEST_F(UtSurfaceQueue, EnqueueFailTwice) /* tbm_surface_queue_error_e tbm_surface_queue_acquire( tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */ -TEST_F(UtSurfaceQueue, AcquireFailNull) +TEST_F(SurfaceQueueTest, AcquireFailNull) { /* test */ result = tbm_surface_queue_acquire(NULL, &surface); @@ -348,19 +348,19 @@ TEST_F(UtSurfaceQueue, AcquireFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AcquireFailInvaildInput) +TEST_F(SurfaceQueueTest, AcquireFailInvaildInput) { result = tbm_surface_queue_acquire(invalid_queue, &surface); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AcquireFailAcquireEmptyQueue) +TEST_F(SurfaceQueueTest, AcquireFailAcquireEmptyQueue) { result = tbm_surface_queue_acquire(invalid_queue, &surface); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AcquireSuccess) +TEST_F(SurfaceQueueTest, AcquireSuccess) { tbm_surface_h surfaces[QUEUE_SIZE] = { NULL }; tbm_surface_h acquired_surface = NULL; @@ -388,7 +388,7 @@ TEST_F(UtSurfaceQueue, AcquireSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire( tbm_surface_queue_h surface_queue, tbm_surface_h surface); */ -TEST_F(UtSurfaceQueue, CancelAcquireFailNull) +TEST_F(SurfaceQueueTest, CancelAcquireFailNull) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -402,7 +402,7 @@ TEST_F(UtSurfaceQueue, CancelAcquireFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, CancelAcquireFailInvaildInput) +TEST_F(SurfaceQueueTest, CancelAcquireFailInvaildInput) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -420,7 +420,7 @@ TEST_F(UtSurfaceQueue, CancelAcquireFailInvaildInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, CancelAcquireSuccess) +TEST_F(SurfaceQueueTest, CancelAcquireSuccess) { tbm_surface_h last_surface = NULL; @@ -453,7 +453,7 @@ TEST_F(UtSurfaceQueue, CancelAcquireSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_release( tbm_surface_queue_h surface_queue, tbm_surface_h surface); */ -TEST_F(UtSurfaceQueue, ReleaseFailNull) +TEST_F(SurfaceQueueTest, ReleaseFailNull) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -470,7 +470,7 @@ TEST_F(UtSurfaceQueue, ReleaseFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, ReleaseFailInvaildInput) +TEST_F(SurfaceQueueTest, ReleaseFailInvaildInput) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -490,7 +490,7 @@ TEST_F(UtSurfaceQueue, ReleaseFailInvaildInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, ReleaseSuccess) +TEST_F(SurfaceQueueTest, ReleaseSuccess) { tbm_surface_h surfaces[QUEUE_SIZE] = { NULL }; @@ -510,7 +510,7 @@ TEST_F(UtSurfaceQueue, ReleaseSuccess) } } -TEST_F(UtSurfaceQueue, ReleaseSequenceSuccess) +TEST_F(SurfaceQueueTest, ReleaseSequenceSuccess) { tbm_surface_h surfaces[QUEUE_SIZE] = { NULL }; @@ -535,7 +535,7 @@ TEST_F(UtSurfaceQueue, ReleaseSequenceSuccess) } } -TEST_F(UtSurfaceQueue, ReleaseFailTwice) +TEST_F(SurfaceQueueTest, ReleaseFailTwice) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -553,76 +553,76 @@ TEST_F(UtSurfaceQueue, ReleaseFailTwice) } /* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, GetWidthFailNull) +TEST_F(SurfaceQueueTest, GetWidthFailNull) { int width = tbm_surface_queue_get_width(NULL); ASSERT_EQ(0, width); } -TEST_F(UtSurfaceQueue, GetWidthFailInvalidInput) +TEST_F(SurfaceQueueTest, GetWidthFailInvalidInput) { int width = tbm_surface_queue_get_width(invalid_queue); ASSERT_EQ(0, width); } -TEST_F(UtSurfaceQueue, GetWidthSuccess) +TEST_F(SurfaceQueueTest, GetWidthSuccess) { int width = tbm_surface_queue_get_width(queue); ASSERT_EQ(this->width, width); } /* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, GetHeightFailNull) +TEST_F(SurfaceQueueTest, GetHeightFailNull) { int height = tbm_surface_queue_get_height(NULL); ASSERT_EQ(0, height); } -TEST_F(UtSurfaceQueue, GetHeightFailInvalidInput) +TEST_F(SurfaceQueueTest, GetHeightFailInvalidInput) { int height = tbm_surface_queue_get_height(invalid_queue); ASSERT_EQ(0, height); } -TEST_F(UtSurfaceQueue, GetHeightSuccess) +TEST_F(SurfaceQueueTest, GetHeightSuccess) { int height = tbm_surface_queue_get_height(queue); ASSERT_EQ(this->height, height); } /* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, GetFormatFailNull) +TEST_F(SurfaceQueueTest, GetFormatFailNull) { int format = tbm_surface_queue_get_format(NULL); ASSERT_EQ(0, format); } -TEST_F(UtSurfaceQueue, GetFormatFailInvalidInput) +TEST_F(SurfaceQueueTest, GetFormatFailInvalidInput) { int format = tbm_surface_queue_get_format(invalid_queue); ASSERT_EQ(0, format); } -TEST_F(UtSurfaceQueue, GetFormatSuccess) +TEST_F(SurfaceQueueTest, GetFormatSuccess) { int format = tbm_surface_queue_get_format(queue); ASSERT_EQ((int)this->format, format); } /* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, GetSizeFailNull) +TEST_F(SurfaceQueueTest, GetSizeFailNull) { int q_size = tbm_surface_queue_get_size(NULL); ASSERT_EQ(0, q_size); } -TEST_F(UtSurfaceQueue, GetSizeFailInvalidInput) +TEST_F(SurfaceQueueTest, GetSizeFailInvalidInput) { int q_size = tbm_surface_queue_get_size(invalid_queue); ASSERT_EQ(0, q_size); } -TEST_F(UtSurfaceQueue, GetSizeSuccess) +TEST_F(SurfaceQueueTest, GetSizeSuccess) { int q_size = tbm_surface_queue_get_size(queue); ASSERT_EQ(QUEUE_SIZE, q_size); @@ -630,13 +630,13 @@ TEST_F(UtSurfaceQueue, GetSizeSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_reset( tbm_surface_queue_h surface_queue, int width, int height, int format); */ -TEST_F(UtSurfaceQueue, ResetFailNull) +TEST_F(SurfaceQueueTest, ResetFailNull) { result = tbm_surface_queue_reset(NULL, width, height, format); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, ResetFailInvalidInput) +TEST_F(SurfaceQueueTest, ResetFailInvalidInput) { result = tbm_surface_queue_reset(invalid_queue, width, height, format); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -651,13 +651,13 @@ TEST_F(UtSurfaceQueue, ResetFailInvalidInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, ResetSuccessEmptyQueue) +TEST_F(SurfaceQueueTest, ResetSuccessEmptyQueue) { result = tbm_surface_queue_reset(queue, width-10, height-10, format); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, ResetSuccessSameParams) +TEST_F(SurfaceQueueTest, ResetSuccessSameParams) { tbm_surface_h surface = NULL; @@ -673,7 +673,7 @@ TEST_F(UtSurfaceQueue, ResetSuccessSameParams) ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid"; } -TEST_F(UtSurfaceQueue, ResetSuccess) +TEST_F(SurfaceQueueTest, ResetSuccess) { tbm_surface_h surface = NULL; @@ -689,7 +689,7 @@ TEST_F(UtSurfaceQueue, ResetSuccess) ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted"; } -TEST_F(UtSurfaceQueue, ResetSequenceSuccess) +TEST_F(SurfaceQueueTest, ResetSequenceSuccess) { tbm_surface_h surface = NULL; @@ -711,13 +711,13 @@ TEST_F(UtSurfaceQueue, ResetSequenceSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_set_size( tbm_surface_queue_h surface_queue, int QUEUE_SIZE, int flush); */ -TEST_F(UtSurfaceQueue, SetSizeFailNull) +TEST_F(SurfaceQueueTest, SetSizeFailNull) { result = tbm_surface_queue_set_size(NULL, QUEUE_SIZE, 0); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetSizeFailInvalidInput) +TEST_F(SurfaceQueueTest, SetSizeFailInvalidInput) { result = tbm_surface_queue_set_size(invalid_queue, QUEUE_SIZE, 0); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -726,7 +726,7 @@ TEST_F(UtSurfaceQueue, SetSizeFailInvalidInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetSizeSuccessTheSameSize) +TEST_F(SurfaceQueueTest, SetSizeSuccessTheSameSize) { tbm_surface_h surface = NULL; @@ -744,7 +744,7 @@ TEST_F(UtSurfaceQueue, SetSizeSuccessTheSameSize) ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted"; } -TEST_F(UtSurfaceQueue, SetSizeSuccessIncrease) +TEST_F(SurfaceQueueTest, SetSizeSuccessIncrease) { tbm_surface_h surface = NULL; @@ -762,7 +762,7 @@ TEST_F(UtSurfaceQueue, SetSizeSuccessIncrease) ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted"; } -TEST_F(UtSurfaceQueue, SetSizeSuccessReduce) +TEST_F(SurfaceQueueTest, SetSizeSuccessReduce) { tbm_surface_h surface = NULL; @@ -781,19 +781,19 @@ TEST_F(UtSurfaceQueue, SetSizeSuccessReduce) } /* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, FlushFailNull) +TEST_F(SurfaceQueueTest, FlushFailNull) { result = tbm_surface_queue_flush(NULL); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, FlushFailInvalidInput) +TEST_F(SurfaceQueueTest, FlushFailInvalidInput) { result = tbm_surface_queue_flush(invalid_queue); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, FlushSuccess) +TEST_F(SurfaceQueueTest, FlushSuccess) { tbm_surface_h surfaces[QUEUE_SIZE]; @@ -819,19 +819,19 @@ TEST_F(UtSurfaceQueue, FlushSuccess) } /* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, FreeFlushFailNull) +TEST_F(SurfaceQueueTest, FreeFlushFailNull) { result = tbm_surface_queue_free_flush(NULL); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, FreeFlushFailInvalidInput) +TEST_F(SurfaceQueueTest, FreeFlushFailInvalidInput) { result = tbm_surface_queue_free_flush(invalid_queue); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, FreeFlushSuccess) +TEST_F(SurfaceQueueTest, FreeFlushSuccess) { tbm_surface_h surfaces[QUEUE_SIZE]; @@ -859,7 +859,7 @@ TEST_F(UtSurfaceQueue, FreeFlushSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddResetCbFailNull) +TEST_F(SurfaceQueueTest, AddResetCbFailNull) { result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -868,13 +868,13 @@ TEST_F(UtSurfaceQueue, AddResetCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddResetCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddResetCbSuccess) +TEST_F(SurfaceQueueTest, AddResetCbSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -894,13 +894,13 @@ TEST_F(UtSurfaceQueue, AddResetCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveResetCbFailNull) +TEST_F(SurfaceQueueTest, RemoveResetCbFailNull) { result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, RemoveResetCbSuccess) +TEST_F(SurfaceQueueTest, RemoveResetCbSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); result = tbm_surface_queue_enqueue(queue, surface); @@ -917,7 +917,7 @@ TEST_F(UtSurfaceQueue, RemoveResetCbSuccess) ASSERT_TRUE(cb_data == 0); } -TEST_F(UtSurfaceQueue, RemoveResetCbFailInvalidInput) +TEST_F(SurfaceQueueTest, RemoveResetCbFailInvalidInput) { result = tbm_surface_queue_dequeue(queue, &surface); result = tbm_surface_queue_enqueue(queue, surface); @@ -943,19 +943,19 @@ TEST_F(UtSurfaceQueue, RemoveResetCbFailInvalidInput) } /* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */ -TEST_F(UtSurfaceQueue, NotifyResetFailNull) +TEST_F(SurfaceQueueTest, NotifyResetFailNull) { result = tbm_surface_queue_notify_reset(NULL); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, NotifyResetFailInvalidInput) +TEST_F(SurfaceQueueTest, NotifyResetFailInvalidInput) { result = tbm_surface_queue_notify_reset(invalid_queue); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, NotifyResetCbSuccess) +TEST_F(SurfaceQueueTest, NotifyResetCbSuccess) { result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -968,17 +968,17 @@ TEST_F(UtSurfaceQueue, NotifyResetCbSuccess) } /* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */ -TEST_F(UtSurfaceQueue, CanDequeueFailNull) +TEST_F(SurfaceQueueTest, CanDequeueFailNull) { ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0)); } -TEST_F(UtSurfaceQueue, CanDequeueFailInvalidInput) +TEST_F(SurfaceQueueTest, CanDequeueFailInvalidInput) { ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0)); } -TEST_F(UtSurfaceQueue, CanDequeueSuccess) +TEST_F(SurfaceQueueTest, CanDequeueSuccess) { int dq_count = 0; @@ -991,7 +991,7 @@ TEST_F(UtSurfaceQueue, CanDequeueSuccess) ASSERT_EQ(QUEUE_SIZE, dq_count); } -TEST_F(UtSurfaceQueue, CanDequeueFailEmptyQueue) +TEST_F(SurfaceQueueTest, CanDequeueFailEmptyQueue) { /*Dequeue all*/ while (tbm_surface_queue_can_dequeue(queue, 0)) { @@ -1005,22 +1005,22 @@ TEST_F(UtSurfaceQueue, CanDequeueFailEmptyQueue) /* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */ -TEST_F(UtSurfaceQueue, CanAcquireFailNull) +TEST_F(SurfaceQueueTest, CanAcquireFailNull) { ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0)); } -TEST_F(UtSurfaceQueue, CanAcquireFailInvalidInput) +TEST_F(SurfaceQueueTest, CanAcquireFailInvalidInput) { ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0)); } -TEST_F(UtSurfaceQueue, CanAcquireFailEmptyQueue) +TEST_F(SurfaceQueueTest, CanAcquireFailEmptyQueue) { ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0)); } -TEST_F(UtSurfaceQueue, CanAcquireSuccess) +TEST_F(SurfaceQueueTest, CanAcquireSuccess) { int acq_count = 0; @@ -1042,7 +1042,7 @@ TEST_F(UtSurfaceQueue, CanAcquireSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddDestroyCbFailNull) +TEST_F(SurfaceQueueTest, AddDestroyCbFailNull) { result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1051,13 +1051,13 @@ TEST_F(UtSurfaceQueue, AddDestroyCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddDestroyCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddDestroyCbSuccess) +TEST_F(SurfaceQueueTest, AddDestroyCbSuccess) { /* test */ result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data); @@ -1073,19 +1073,19 @@ TEST_F(UtSurfaceQueue, AddDestroyCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveDestroyCbFailNull) +TEST_F(SurfaceQueueTest, RemoveDestroyCbFailNull) { result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, RemoveDestroyCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveDestroyCbSuccess) +TEST_F(SurfaceQueueTest, RemoveDestroyCbSuccess) { result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1102,7 +1102,7 @@ TEST_F(UtSurfaceQueue, RemoveDestroyCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddDequeuableCbFailNull) +TEST_F(SurfaceQueueTest, AddDequeuableCbFailNull) { result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1111,13 +1111,13 @@ TEST_F(UtSurfaceQueue, AddDequeuableCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddDequeuableCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddDequeuableCbSuccess) +TEST_F(SurfaceQueueTest, AddDequeuableCbSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1139,20 +1139,20 @@ TEST_F(UtSurfaceQueue, AddDequeuableCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveDequeuableCbFailNull) +TEST_F(SurfaceQueueTest, RemoveDequeuableCbFailNull) { result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, RemoveDequeuableCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveDequeuableCbSuccess) +TEST_F(SurfaceQueueTest, RemoveDequeuableCbSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1175,7 +1175,7 @@ TEST_F(UtSurfaceQueue, RemoveDequeuableCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddDequeueCbFailNull) +TEST_F(SurfaceQueueTest, AddDequeueCbFailNull) { result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1184,13 +1184,13 @@ TEST_F(UtSurfaceQueue, AddDequeueCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddDequeueCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddDequeueCbSuccess) +TEST_F(SurfaceQueueTest, AddDequeueCbSuccess) { /* test */ result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data); @@ -1204,20 +1204,20 @@ TEST_F(UtSurfaceQueue, AddDequeueCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveDequeueCbFailNull) +TEST_F(SurfaceQueueTest, RemoveDequeueCbFailNull) { result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, RemoveDequeueCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveDequeueCbSuccess) +TEST_F(SurfaceQueueTest, RemoveDequeueCbSuccess) { /* test */ result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data); @@ -1239,7 +1239,7 @@ TEST_F(UtSurfaceQueue, RemoveDequeueCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddCanDequeueCbFailNull) +TEST_F(SurfaceQueueTest, 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); @@ -1248,13 +1248,13 @@ TEST_F(UtSurfaceQueue, AddCanDequeueCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddCanDequeueCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddCanDequeueCbSuccess) +TEST_F(SurfaceQueueTest, AddCanDequeueCbSuccess) { /* test */ result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data); @@ -1267,20 +1267,20 @@ TEST_F(UtSurfaceQueue, AddCanDequeueCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveCanDequeueCbFailNull) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveCanDequeueCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveCanDequeueCbSuccess) +TEST_F(SurfaceQueueTest, 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); @@ -1296,7 +1296,7 @@ TEST_F(UtSurfaceQueue, RemoveCanDequeueCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddAcquirableCbFailNull) +TEST_F(SurfaceQueueTest, AddAcquirableCbFailNull) { result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1305,13 +1305,13 @@ TEST_F(UtSurfaceQueue, AddAcquirableCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddAcquirableCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddAcquirableCbSuccess) +TEST_F(SurfaceQueueTest, AddAcquirableCbSuccess) { tbm_surface_queue_dequeue(queue, &surface); @@ -1327,20 +1327,20 @@ TEST_F(UtSurfaceQueue, AddAcquirableCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveAcquirableCbFailNull) +TEST_F(SurfaceQueueTest, RemoveAcquirableCbFailNull) { result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, RemoveAcquirableCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveAcquirableCbSuccess) +TEST_F(SurfaceQueueTest, RemoveAcquirableCbSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); @@ -1359,7 +1359,7 @@ TEST_F(UtSurfaceQueue, RemoveAcquirableCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */ -TEST_F(UtSurfaceQueue, AddTraceCbFailNull) +TEST_F(SurfaceQueueTest, 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); @@ -1368,13 +1368,13 @@ TEST_F(UtSurfaceQueue, AddTraceCbFailNull) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, AddTraceCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, AddTraceCbSuccess) +TEST_F(SurfaceQueueTest, AddTraceCbSuccess) { trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE; @@ -1411,20 +1411,20 @@ TEST_F(UtSurfaceQueue, AddTraceCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb( tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */ -TEST_F(UtSurfaceQueue, RemoveTraceCbFailNull) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveTraceCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, RemoveTraceCbSuccess) +TEST_F(SurfaceQueueTest, RemoveTraceCbSuccess) { trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE; @@ -1442,21 +1442,21 @@ TEST_F(UtSurfaceQueue, RemoveTraceCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb( tbm_surface_queue_h surface_queue, tbm_surface_alloc_cb alloc_cb, tbm_surface_free_cb free_cb, void *data); */ -TEST_F(UtSurfaceQueue, SetAllocCbFailNull) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, SetAllocCbFailInvalidInput) +TEST_F(SurfaceQueueTest, 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); } -TEST_F(UtSurfaceQueue, SetAllocCbSuccess) +TEST_F(SurfaceQueueTest, SetAllocCbSuccess) { result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler, tbm_surface_free_cb_handler, alien_surface); @@ -1476,7 +1476,7 @@ TEST_F(UtSurfaceQueue, SetAllocCbSuccess) /* tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num( tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num); */ -TEST_F(UtSurfaceQueue, GetTraceSurfaceNumFailNull) +TEST_F(SurfaceQueueTest, GetTraceSurfaceNumFailNull) { int num = 0; @@ -1493,7 +1493,7 @@ TEST_F(UtSurfaceQueue, GetTraceSurfaceNumFailNull) } -TEST_F(UtSurfaceQueue, GetTraceSurfaceNumFailInvalidInput) +TEST_F(SurfaceQueueTest, GetTraceSurfaceNumFailInvalidInput) { int num = 0; @@ -1501,7 +1501,7 @@ TEST_F(UtSurfaceQueue, GetTraceSurfaceNumFailInvalidInput) ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, GetTraceSurfaceNumSuccess) +TEST_F(SurfaceQueueTest, GetTraceSurfaceNumSuccess) { int num = 0; @@ -1547,38 +1547,38 @@ TEST_F(UtSurfaceQueue, GetTraceSurfaceNumSuccess) } /* tbm_surface_queue_error_e tbm_surface_queue_set_modes( tbm_surface_queue_h surface_queue, int modes); */ -TEST_F(UtSurfaceQueue, SetModesFailNull) +TEST_F(SurfaceQueueTest, SetModesFailNull) { result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetModesFailInvalidInput) +TEST_F(SurfaceQueueTest, SetModesFailInvalidInput) { result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetModesSuccess) +TEST_F(SurfaceQueueTest, SetModesSuccess) { result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); } /* tbm_surface_queue_set_sync_count() */ -TEST_F(UtSurfaceQueue, SetSyncCountFailNull) +TEST_F(SurfaceQueueTest, SetSyncCountFailNull) { result = tbm_surface_queue_set_sync_count(NULL, 1); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetSyncCountFailInvalidInput) +TEST_F(SurfaceQueueTest, SetSyncCountFailInvalidInput) { result = tbm_surface_queue_set_sync_count(invalid_queue, 1); ASSERT_NE(TBM_SURFACE_QUEUE_ERROR_NONE, result); } -TEST_F(UtSurfaceQueue, SetSyncCountSuccess) +TEST_F(SurfaceQueueTest, SetSyncCountSuccess) { result = tbm_surface_queue_dequeue(queue, &surface); ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, result); -- 2.7.4