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

Change-Id: If82a337d08ddc8a632a40679e7feaa13f8cf4a7a

diff --git a/haltests/tc_tbm.h b/haltests/tc_tbm.h
index f4e05dd..21b703d 100644 (file)
--- a/haltests/tc_tbm.h
+++ b/haltests/tc_tbm.h
@@ -97,10 +97,10 @@
 }
 
 #define TBM_UT_DUMP_DIR            "/tmp/tbm_dump"
-#define UT_TBM_INVALID_VALUE       -42
+#define TBM_UT_INVALID_VALUE       -42
 #define TBM_UT_INVALID_UINT_VALUE  99999
-#define UT_TBM_BO_SIZE             1024
-#define UT_TBM_SURFACE_QUEUE_SIZE  4
+#define TBM_UT_BO_SIZE             1024
+#define TBM_UT_SURFACE_QUEUE_SIZE  4
 
 using ::testing::TestWithParam;
 using ::testing::Bool;

diff --git a/haltests/tc_tbm_bo.cpp b/haltests/tc_tbm_bo.cpp
index 277aff6..b539863 100644 (file)
--- a/haltests/tc_tbm_bo.cpp
+++ b/haltests/tc_tbm_bo.cpp
@@ -70,7 +70,7 @@ TEST_F(TBMBo, BoAllocUnref)
 {
        tbm_bo bo;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -81,11 +81,11 @@ TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
 {
        tbm_bo bo;
 
-       bo = tbm_bo_alloc(NULL, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(NULL, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(invalid_bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
@@ -103,22 +103,22 @@ TEST_F(TBMBo, BoAllocWithFlagsParamTest)
 {
        tbm_bo bo;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_SCANOUT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_SCANOUT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_NONCACHABLE);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_NONCACHABLE);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_WC);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_WC);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
@@ -130,7 +130,7 @@ TEST_F(TBMBo, BoRef)
 {
        tbm_bo bo;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -174,7 +174,7 @@ TEST_F(TBMBo, BoMapUnmap)
        tbm_bo_handle bo_handle;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -209,7 +209,7 @@ TEST_F(TBMBo, BoMapWithDeviceParamTest)
        tbm_bo_handle bo_handle;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -259,7 +259,7 @@ TEST_F(TBMBo, BoMapWithOptParamTest)
        tbm_bo_handle bo_handle;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -302,7 +302,7 @@ TEST_F(TBMBo, BoUnmapWithBoParamTest)
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(invalid_bo);
@@ -319,7 +319,7 @@ TEST_F(TBMBo, BoGetHandle)
        tbm_bo bo;
        tbm_bo_handle bo_handle;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
@@ -345,7 +345,7 @@ TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
        tbm_bo bo;
        tbm_bo_handle bo_handle;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -383,7 +383,7 @@ TEST_F(TBMBo, BoExport)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
                return;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -421,7 +421,7 @@ TEST_F(TBMBo, BoExportFd)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
                return;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -459,7 +459,7 @@ TEST_F(TBMBo, BoImport)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
                return;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo1, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -517,7 +517,7 @@ TEST_F(TBMBo, BoImportTwice)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
                return;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo1, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -553,7 +553,7 @@ TEST_F(TBMBo, BoImportFd)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
                return;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo1, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -611,7 +611,7 @@ TEST_F(TBMBo, BoImportFdTwice)
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
                return;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo1, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -644,7 +644,7 @@ TEST_F(TBMBo, BoSize)
        tbm_bo bo;
        int size = 0;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -677,7 +677,7 @@ TEST_F(TBMBo, BoLocked)
        tbm_bo_handle bo_handle;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -731,7 +731,7 @@ TEST_F(TBMBo, BoLockedOnce)
 
        setenv("BUFMGR_LOCK_TYPE", "once", 1);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
@@ -757,7 +757,7 @@ TEST_F(TBMBo, BoLockedAlways)
 
        setenv("BUFMGR_LOCK_TYPE", "always", 1);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
@@ -783,7 +783,7 @@ TEST_F(TBMBo, BoLockedNone)
 
        setenv("BUFMGR_LOCK_TYPE", "none", 1);
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
@@ -804,11 +804,11 @@ TEST_F(TBMBo, BoSwap)
        tbm_bo bo1, bo2;
        int ret;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo1, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo2 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo2, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -828,7 +828,7 @@ TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
        tbm_bo bo;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -867,11 +867,11 @@ TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
        tbm_bo bo1, bo2;
        int ret;
 
-       bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo1 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, bo1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE + 256, TBM_BO_DEFAULT);
+       bo2 = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE + 256, TBM_BO_DEFAULT);
        EXPECT_NE(nullptr, bo2);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -893,7 +893,7 @@ TEST_F(TBMBo, BoAddUserData)
        tbm_bo bo;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -923,7 +923,7 @@ TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
        tbm_bo bo;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -946,7 +946,7 @@ TEST_F(TBMBo, BoDeleteUserData)
        tbm_bo bo;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
 
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
@@ -979,7 +979,7 @@ TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
        tbm_bo bo;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -1016,7 +1016,7 @@ TEST_F(TBMBo, BoSetUserData)
        int data1 = 0, data2 = 0;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -1064,7 +1064,7 @@ TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
        int data = 0;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -1100,7 +1100,7 @@ TEST_F(TBMBo, BoGetUserData)
        int *data2;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -1149,7 +1149,7 @@ TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
        int *data;
        int ret;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, TBM_BO_DEFAULT);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
@@ -1187,7 +1187,7 @@ TEST_F(TBMBo, BoGetFlags)
        tbm_bo bo;
        int flags1 = TBM_BO_DEFAULT, flags2 = -1;
 
-       bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
+       bo = tbm_bo_alloc(bufmgr, TBM_UT_BO_SIZE, flags1);
        EXPECT_NE(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 

diff --git a/haltests/tc_tbm_bufmgr.cpp b/haltests/tc_tbm_bufmgr.cpp
index 888b017..9357b69 100644 (file)
--- a/haltests/tc_tbm_bufmgr.cpp
+++ b/haltests/tc_tbm_bufmgr.cpp
@@ -80,7 +80,7 @@ TEST_F(TBMBufmgr, BufmgrGetCapabilityWithNullBufmgr)
 
 TEST_F(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
 {
-       tbm_bufmgr bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
+       tbm_bufmgr bufmgr = (tbm_bufmgr)TBM_UT_INVALID_VALUE;
        unsigned int capability;
 
        capability = tbm_bufmgr_get_capability(bufmgr);
@@ -93,7 +93,7 @@ TEST_F(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
 TEST_F(TBMBufmgr, BufmgrBindNativeDisplay)
 {
        int ret;
-       void *native_display = (void *)UT_TBM_INVALID_VALUE;
+       void *native_display = (void *)TBM_UT_INVALID_VALUE;
 
        ret = tbm_bufmgr_bind_native_display(bufmgr, native_display);
        ASSERT_EQ(ret, 1);
@@ -102,7 +102,7 @@ TEST_F(TBMBufmgr, BufmgrBindNativeDisplay)
 TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
 {
        int ret;
-       void *native_display = (void *)UT_TBM_INVALID_VALUE;
+       void *native_display = (void *)TBM_UT_INVALID_VALUE;
 
        ret = tbm_bufmgr_bind_native_display(NULL, native_display);
        ASSERT_EQ(ret, 0);
@@ -111,7 +111,7 @@ TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
 TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithWrongBufmgr)
 {
        int ret;
-       void *native_display = (void *)UT_TBM_INVALID_VALUE;
+       void *native_display = (void *)TBM_UT_INVALID_VALUE;
 
        ret = tbm_bufmgr_bind_native_display(NULL, native_display);
        ASSERT_EQ(ret, 0);

diff --git a/haltests/tc_tbm_log.cpp b/haltests/tc_tbm_log.cpp
index 684fda2..0ff44e2 100644 (file)
--- a/haltests/tc_tbm_log.cpp
+++ b/haltests/tc_tbm_log.cpp
@@ -84,7 +84,7 @@ TEST(TBMLog, logDlogNormal)
 TEST(TBMLog, logDlogUnknownLevel)
 {
        tbm_log_enable_dlog(1);
-       tbm_log_print(UT_TBM_INVALID_VALUE, "haltest");
+       tbm_log_print(TBM_UT_INVALID_VALUE, "haltest");
 }
 
 TEST(TBMLog, logSetAssertLevel)

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(