haltest: use memory pointer intead TBM_UT_INVALID_UINT_VALUE

[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..277aff6 100644 (file)
--- a/haltests/tc_tbm_bo.cpp
+++ b/haltests/tc_tbm_bo.cpp
@@ -59,6 +59,11 @@ 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)
@@ -75,14 +80,11 @@ 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, UT_TBM_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);
        EXPECT_EQ(bo, nullptr);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
@@ -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));
 }
@@ -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));
@@ -296,14 +292,12 @@ 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));
@@ -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));
@@ -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));
@@ -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));
@@ -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));
@@ -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));
@@ -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));
@@ -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));
@@ -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);
        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);
@@ -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));
@@ -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));
@@ -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));
@@ -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));
@@ -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));