Exclude dlog dependency when dlog disabled.

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

diff --git a/haltests/tc_tbm_bo.cpp b/haltests/tc_tbm_bo.cpp
index 2e938da..b539863 100644 (file)
--- a/haltests/tc_tbm_bo.cpp
+++ b/haltests/tc_tbm_bo.cpp
@@ -59,13 +59,18 @@ void TBMBo::TearDown()
        TBMBufmgr::TearDown();
 }
 
+static int memory_for_invalid_param;
+static tbm_bufmgr invalid_bufmgr = (tbm_bufmgr)&memory_for_invalid_param;
+static tbm_bo invalid_bo = (tbm_bo)&memory_for_invalid_param;
+static tbm_bo invalid_bo2 = (tbm_bo)&memory_for_invalid_param;
+
 /* tbm_bo_alloc() */
 
 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));
 
@@ -75,15 +80,12 @@ TEST_F(TBMBo, BoAllocUnref)
 TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
 {
        tbm_bo bo;
-       tbm_bufmgr invalid_bufmgr;
 
-       invalid_bufmgr = NULL;
-       bo = tbm_bo_alloc(invalid_bufmgr, 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));
 
-       invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
-       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));
 }
@@ -101,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);
@@ -128,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));
 
@@ -142,13 +144,12 @@ TEST_F(TBMBo, BoRef)
 
 TEST_F(TBMBo, BoRefWithBoParamTest)
 {
-       tbm_bo bo, invalid_bo;
+       tbm_bo bo;
 
        bo = tbm_bo_ref(NULL);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        bo = tbm_bo_ref(invalid_bo);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -158,12 +159,9 @@ TEST_F(TBMBo, BoRefWithBoParamTest)
 
 TEST_F(TBMBo, BoUnrefWithBoParamTest)
 {
-       tbm_bo invalid_bo;
-
        tbm_bo_unref(NULL);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        tbm_bo_unref(invalid_bo);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
@@ -176,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));
 
@@ -193,14 +191,12 @@ TEST_F(TBMBo, BoMapUnmap)
 
 TEST_F(TBMBo, BoMapWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        tbm_bo_handle bo_handle;
 
        bo_handle = tbm_bo_map(NULL, TBM_DEVICE_CPU, TBM_OPTION_READ);
        EXPECT_EQ(bo_handle.ptr, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        bo_handle = tbm_bo_map(invalid_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
        EXPECT_EQ(bo_handle.ptr, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -213,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));
 
@@ -263,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));
 
@@ -296,19 +292,17 @@ TEST_F(TBMBo, BoMapWithOptParamTest)
 TEST_F(TBMBo, BoUnmapWithBoParamTest)
 {
        tbm_bo bo;
-       tbm_bo invalid_bo;
        int ret;
 
        ret = tbm_bo_unmap(NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        ret = tbm_bo_unmap(invalid_bo);
        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);
@@ -325,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);
@@ -337,13 +331,10 @@ TEST_F(TBMBo, BoGetHandle)
 TEST_F(TBMBo, BoGetHandleWithBoParamTest)
 {
        tbm_bo_handle bo_handle;
-       tbm_bo invalid_bo;
-
        bo_handle = tbm_bo_get_handle(NULL, TBM_DEVICE_DEFAULT);
        EXPECT_EQ(bo_handle.ptr, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        bo_handle = tbm_bo_get_handle(invalid_bo, TBM_DEVICE_DEFAULT);
        EXPECT_EQ(bo_handle.ptr, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -354,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));
 
@@ -392,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));
 
@@ -406,7 +397,6 @@ TEST_F(TBMBo, BoExport)
 
 TEST_F(TBMBo, BoExportWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        tbm_key bo_key;
 
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
@@ -416,7 +406,6 @@ TEST_F(TBMBo, BoExportWithBoParamTest)
        EXPECT_EQ(bo_key, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        bo_key = tbm_bo_export(invalid_bo);
        EXPECT_EQ(bo_key, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -432,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));
 
@@ -446,7 +435,6 @@ TEST_F(TBMBo, BoExportFd)
 
 TEST_F(TBMBo, BoExportFdWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        tbm_fd bo_fd;
 
        if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
@@ -456,7 +444,6 @@ TEST_F(TBMBo, BoExportFdWithBoParamTest)
        EXPECT_EQ(bo_fd, -1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        bo_fd = tbm_bo_export_fd(invalid_bo);
        EXPECT_EQ(bo_fd, -1);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -472,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));
 
@@ -493,7 +480,6 @@ TEST_F(TBMBo, BoImport)
 
 TEST_F(TBMBo, BoImportWithBufmgrParamTest)
 {
-       tbm_bufmgr invalid_bufmgr;
        tbm_bo bo;
        tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
 
@@ -504,7 +490,6 @@ TEST_F(TBMBo, BoImportWithBufmgrParamTest)
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
        bo = tbm_bo_import(invalid_bufmgr, bo_key);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -532,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));
 
@@ -568,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));
 
@@ -589,7 +574,6 @@ TEST_F(TBMBo, BoImportFd)
 
 TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
 {
-       tbm_bufmgr invalid_bufmgr;
        tbm_bo bo;
        tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
 
@@ -600,7 +584,6 @@ TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
        bo = tbm_bo_import_fd(invalid_bufmgr, bo_fd);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -628,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));
 
@@ -661,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));
 
@@ -675,14 +658,12 @@ TEST_F(TBMBo, BoSize)
 
 TEST_F(TBMBo, BoSizeWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        int size = 0;
 
        size = tbm_bo_size(NULL);
        EXPECT_EQ(size, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        size = tbm_bo_size(invalid_bo);
        EXPECT_EQ(size, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -696,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));
 
@@ -729,14 +710,12 @@ TEST_F(TBMBo, BoLocked)
 
 TEST_F(TBMBo, BoLockedWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        int ret;
 
        ret = tbm_bo_locked(NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
        ret = tbm_bo_locked(invalid_bo);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -752,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);
@@ -778,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);
@@ -804,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);
@@ -825,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));
 
@@ -846,16 +825,13 @@ TEST_F(TBMBo, BoSwap)
 
 TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
 {
-       tbm_bo bo, invalid_bo1, invalid_bo2;
+       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));
 
-       invalid_bo1 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
-       invalid_bo2 = (tbm_bo)TBM_UT_INVALID_UINT_VALUE;
-
        ret = tbm_bo_swap(NULL, NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -866,16 +842,16 @@ TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       ret = tbm_bo_swap(invalid_bo1, invalid_bo2);
+       ret = tbm_bo_swap(invalid_bo, invalid_bo2);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
        ret = tbm_bo_swap(bo, invalid_bo2);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-       ret = tbm_bo_swap(invalid_bo1, bo);
+       ret = tbm_bo_swap(invalid_bo, bo);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-       ret = tbm_bo_swap(invalid_bo1, NULL);
+       ret = tbm_bo_swap(invalid_bo, NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
        ret = tbm_bo_swap(NULL, invalid_bo2);
@@ -891,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));
 
@@ -917,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));
 
@@ -931,14 +907,12 @@ TEST_F(TBMBo, BoAddUserData)
 
 TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        int ret;
 
        ret = tbm_bo_add_user_data(NULL, 4887, NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
        ret = tbm_bo_add_user_data(invalid_bo, 4887, NULL);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -949,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));
 
@@ -972,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);
@@ -989,14 +963,12 @@ TEST_F(TBMBo, BoDeleteUserData)
 
 TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
 {
-       tbm_bo invalid_bo;
        int ret;
 
        ret = tbm_bo_delete_user_data(NULL, 4887);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
        ret = tbm_bo_delete_user_data(invalid_bo, 4887);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -1007,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));
 
@@ -1044,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));
 
@@ -1072,7 +1044,6 @@ TEST_F(TBMBo, BoSetUserData)
 
 TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        unsigned long key = 4887;
        int data1 = 0, data2 = 0;
        int ret;
@@ -1081,7 +1052,6 @@ TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
        ret = tbm_bo_set_user_data(invalid_bo, key, &data2);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -1094,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));
 
@@ -1130,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));
 
@@ -1158,7 +1128,6 @@ TEST_F(TBMBo, BoGetUserData)
 
 TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        unsigned long key = 4887;
        int *data1;
        int *data2;
@@ -1168,7 +1137,6 @@ TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
        ret = tbm_bo_get_user_data(invalid_bo, key, (void **)&data2);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -1181,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));
 
@@ -1219,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));
 
@@ -1233,14 +1201,12 @@ TEST_F(TBMBo, BoGetFlags)
 
 TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
 {
-       tbm_bo invalid_bo;
        int flags = -1;
 
        flags = tbm_bo_get_flags(NULL);
        EXPECT_TRUE(flags == 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_bo = (tbm_bo)UT_TBM_INVALID_VALUE;
        flags = tbm_bo_get_flags(invalid_bo);
        EXPECT_TRUE(flags == 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));