tc: fix the prefix of the definition in tc_tbm.h

[platform/core/uifw/libtbm.git] / haltests / tc_tbm_surface_queue.cpp

diff --git a/haltests/tc_tbm_surface_queue.cpp b/haltests/tc_tbm_surface_queue.cpp
index 09fe4ca..5c647d7 100644 (file)
--- a/haltests/tc_tbm_surface_queue.cpp
+++ b/haltests/tc_tbm_surface_queue.cpp
@@ -71,7 +71,7 @@ void TBMSurfaceQueue::SetUp()
        alien_surface = tbm_surface_create(width, height, format);
        EXPECT_NE((tbm_surface_h)NULL, alien_surface);
 
-       queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+       queue = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
        EXPECT_NE((tbm_surface_queue_h)NULL, queue);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
@@ -124,7 +124,7 @@ 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);
+       queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, queue1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -132,7 +132,7 @@ TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
        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,
+/* tbm_surface_queue_h tbm_surface_queue_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
                int height, int format, int flags); */
 TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
 {
@@ -142,20 +142,20 @@ TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
        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);
+       queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
        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);
+       queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
        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);
+       queue1 = tbm_surface_queue_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
        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,
+/* tbm_surface_queue_h tbm_surface_queue_sequence_create(int TBM_UT_SURFACE_QUEUE_SIZE, int width,
                int height, int format, int flags); */
 TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
 {
@@ -165,15 +165,15 @@ TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
        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);
+       queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
        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);
+       queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
        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);
+       queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
        EXPECT_EQ(nullptr, queue1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
@@ -182,7 +182,7 @@ 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);
+       queue1 = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, queue1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -234,7 +234,7 @@ TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
 TEST_F(TBMSurfaceQueue, DequeueSuccess)
 {
        /* do dequeue three times */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                EXPECT_NE((tbm_surface_h)NULL, surface);
@@ -249,7 +249,7 @@ TEST_F(TBMSurfaceQueue, DequeueSuccess)
        tbm_surface_h *surfaces, int *num); */
 TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
        int num;
 
        result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
@@ -261,7 +261,7 @@ TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
 
 TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
        int num;
 
        result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
@@ -270,7 +270,7 @@ TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
 
 TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
        int num = 0;
 
        /* test: empty queue*/
@@ -279,7 +279,7 @@ TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
        EXPECT_EQ(0, num);
 
        /* do dequeue three times */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                EXPECT_NE(nullptr, surface);
@@ -288,14 +288,14 @@ TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
        /* test */
        result = tbm_surface_queue_get_surfaces(queue, surfaces, &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++)
+       EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, num);
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
                EXPECT_NE(nullptr, surfaces[i]);
 
        /* test: get only number of surfaces */
        result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
        EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+       EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, num);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
@@ -332,7 +332,7 @@ TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
 {
        tbm_surface_h last_surface = NULL;
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                EXPECT_NE(nullptr, surface);
@@ -386,16 +386,16 @@ TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
 
 TEST_F(TBMSurfaceQueue, EnqueueSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                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++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
@@ -440,11 +440,11 @@ TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
 
 TEST_F(TBMSurfaceQueue, AcquireSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
        tbm_surface_h acquired_surface = NULL;
 
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
@@ -452,7 +452,7 @@ TEST_F(TBMSurfaceQueue, AcquireSuccess)
        }
 
        /* test */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_acquire(queue, &acquired_surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                EXPECT_EQ(surfaces[i], acquired_surface);
@@ -502,14 +502,14 @@ TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
 {
        tbm_surface_h last_surface = NULL;
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surface);
                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++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_acquire(queue, &surface);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
@@ -570,9 +570,9 @@ TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
 
 TEST_F(TBMSurfaceQueue, ReleaseSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
@@ -582,7 +582,7 @@ TEST_F(TBMSurfaceQueue, ReleaseSuccess)
        }
 
        /* test */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_release(queue, surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
@@ -590,14 +590,14 @@ TEST_F(TBMSurfaceQueue, ReleaseSuccess)
 
 TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE] = { NULL };
 
        /* 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);
+       queue = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
        EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(tbm_get_last_error()));
 
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
@@ -607,7 +607,7 @@ TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
        }
 
        /* test */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_release(queue, surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
        }
@@ -714,7 +714,7 @@ TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
 TEST_F(TBMSurfaceQueue, GetSizeSuccess)
 {
        int q_size = tbm_surface_queue_get_size(queue);
-       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE,  q_size);
+       EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE,  q_size);
        EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
@@ -785,7 +785,7 @@ TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
 
        /* 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);
+       queue = tbm_surface_queue_sequence_create(TBM_UT_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
        ASSERT_TRUE(queue != NULL);
 
        result = tbm_surface_queue_dequeue(queue, &surface);
@@ -800,16 +800,16 @@ TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_set_size(
-               tbm_surface_queue_h surface_queue, int UT_TBM_SURFACE_QUEUE_SIZE, int flush); */
+               tbm_surface_queue_h surface_queue, int TBM_UT_SURFACE_QUEUE_SIZE, int flush); */
 TEST_F(TBMSurfaceQueue, SetSizeFailNull)
 {
-       result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+       result = tbm_surface_queue_set_size(NULL, TBM_UT_SURFACE_QUEUE_SIZE, 0);
        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);
+       result = tbm_surface_queue_set_size(invalid_queue, TBM_UT_SURFACE_QUEUE_SIZE, 0);
        EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
 
        result = tbm_surface_queue_set_size(NULL, 0, 0);
@@ -824,12 +824,12 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE, 0);
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE, 1);
        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";
 }
@@ -842,12 +842,12 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE+1, 0);
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE+2, 1);
        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";
 }
@@ -860,12 +860,12 @@ TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE-1, 0);
        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);
+       result = tbm_surface_queue_set_size(queue, TBM_UT_SURFACE_QUEUE_SIZE-2, 1);
        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";
 }
@@ -885,14 +885,14 @@ TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
 
 TEST_F(TBMSurfaceQueue, FlushSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 
        /*test: flushing not initialized queue*/
        result = tbm_surface_queue_flush(queue);
        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++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_enqueue(queue, surfaces[i]);
@@ -904,7 +904,7 @@ TEST_F(TBMSurfaceQueue, FlushSuccess)
        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++)
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
                ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 }
 
@@ -923,7 +923,7 @@ TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
 
 TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
 {
-       tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+       tbm_surface_h surfaces[TBM_UT_SURFACE_QUEUE_SIZE];
 
        /*test: flushing not initialized queue*/
        result = tbm_surface_queue_free_flush(queue);
@@ -931,7 +931,7 @@ TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
 
 
        /* init queue */
-       for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++) {
                result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
@@ -943,7 +943,7 @@ TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
        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++)
+       for (int i = 0; i < TBM_UT_SURFACE_QUEUE_SIZE; i++)
                ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
 }
 
@@ -1103,7 +1103,7 @@ TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
                EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
                dq_count++;
        }
-       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
+       EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, dq_count);
 }
 
 TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
@@ -1152,7 +1152,7 @@ TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
                acq_count++;
        }
 
-       EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
+       EXPECT_EQ(TBM_UT_SURFACE_QUEUE_SIZE, acq_count);
 }
 
 /* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(