utest: rename UtSurfaceQueue to SurfaceQueueTest

Change-Id: I5809f4207959451db722ca73c459d216c24bcff0

diff --git a/utests/ut.cpp b/utests/ut.cpp
index bc207de..a52ce6e 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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);