haltest: use memory pointer intead TBM_UT_INVALID_UINT_VALUE

Change-Id: I9e114a1e4c472a8db8a463d8d2868d22e4aa3a19

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));

diff --git a/haltests/tc_tbm_bufmgr.cpp b/haltests/tc_tbm_bufmgr.cpp
index 19ea7b5..888b017 100644 (file)
--- a/haltests/tc_tbm_bufmgr.cpp
+++ b/haltests/tc_tbm_bufmgr.cpp
@@ -56,6 +56,9 @@ void TBMBufmgr::TearDown()
        TBMEnv::TearDown();
 }
 
+static int memory_for_invalid_param;
+static tbm_bufmgr invalid_bufmgr = (tbm_bufmgr)&memory_for_invalid_param;
+
 /* tbm_bufmgr_get_capability() */
 TEST_F(TBMBufmgr, BufmgrGetCapability)
 {
@@ -133,12 +136,10 @@ TEST_F(TBMBufmgr, BufmgrSetBoLockType)
 
 TEST_F(TBMBufmgr, BufmgrSetBoLockTypeWithBufmgrParamTest)
 {
-       tbm_bufmgr invalid_bufmgr;
        int ret;
 
        ret = tbm_bufmgr_set_bo_lock_type(NULL, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
        EXPECT_EQ(ret, 0);
-       invalid_bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
        ret = tbm_bufmgr_set_bo_lock_type(invalid_bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
        EXPECT_EQ(ret, 0);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));

diff --git a/haltests/tc_tbm_surface.cpp b/haltests/tc_tbm_surface.cpp
index 6c75858..36fda89 100644 (file)
--- a/haltests/tc_tbm_surface.cpp
+++ b/haltests/tc_tbm_surface.cpp
@@ -87,6 +87,9 @@ void TBMSurface::TearDown()
        TBMBufmgr::TearDown();
 }
 
+static int memory_for_invalid_param;
+static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
+
 TEST_F(TBMSurface, SurfaceCeateFailInvalidGeometry)
 {
        tbm_surface_h surf1 = NULL;
@@ -125,7 +128,6 @@ TEST_F(TBMSurface, SurfaceCeateSuccess)
 
 TEST_F(TBMSurface, SurfaceGetFormatFailInvalidInput)
 {
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
        tbm_format fmt = tbm_surface_get_format(invalid_surface);
        EXPECT_EQ(0, fmt);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
@@ -150,7 +152,6 @@ TEST_F(TBMSurface, SurfaceGetFormatSuccess)
 
 TEST_F(TBMSurface, SurfaceGetWidthFailInvalidInput)
 {
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
        int width = tbm_surface_get_width(invalid_surface);
        EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
@@ -175,7 +176,6 @@ TEST_F(TBMSurface, SurfaceGetWidthSuccess)
 
 TEST_F(TBMSurface, SurfaceGetHeightFailInvalidInput)
 {
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
        int height = tbm_surface_get_height(invalid_surface);
        EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
@@ -200,7 +200,6 @@ TEST_F(TBMSurface, SurfaceGetHeightSuccess)
 
 TEST_F(TBMSurface, SurfaceGetInfoInvalidInput)
 {
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
        tbm_surface_info_s info;
        tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
 
@@ -247,7 +246,6 @@ TEST_F(TBMSurface, SurfaceMapFailInvalidInput)
 {
        tbm_surface_info_s info;
        tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
 
        result = (tbm_surface_error_e)tbm_surface_map(invalid_surface, 0, &info);
        EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
@@ -291,7 +289,6 @@ TEST_F(TBMSurface, SurfaceMapSuccess)
 TEST_F(TBMSurface, SurfaceUnmapFailInvalidInput)
 {
        tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-       tbm_surface_h invalid_surface = (tbm_surface_h)1;
        result = (tbm_surface_error_e)tbm_surface_unmap(invalid_surface);
        EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
        EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));

diff --git a/haltests/tc_tbm_surface_internal.cpp b/haltests/tc_tbm_surface_internal.cpp
index a3a27ec..ceacb27 100644 (file)
--- a/haltests/tc_tbm_surface_internal.cpp
+++ b/haltests/tc_tbm_surface_internal.cpp
@@ -74,6 +74,9 @@ void TBMSurfaceInternal::TearDown()
        TBMBufmgr::TearDown();
 }
 
+static int memory_for_invalid_param;
+static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
+
 /* tbm_surface_h tbm_surface_internal_create_with_flags(int width, int height, int format, int flags) */
 TEST_F(TBMSurfaceInternal, SurfaceInternalCeateDestroyTest)
 {
@@ -128,15 +131,12 @@ TEST_F(TBMSurfaceInternal, SurfaceInteranlDestroyTwiceTest)
 /* tbm_surface_internal_is_valid(tbm_surface_h surface) */
 TEST_F(TBMSurfaceInternal, SurfaceInteranlIsValid)
 {
-       tbm_surface_h invalid_surface;
-
        EXPECT_TRUE(tbm_surface_internal_is_valid(surface));
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        EXPECT_FALSE(tbm_surface_internal_is_valid(NULL));
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       invalid_surface = (tbm_surface_h)UT_TBM_INVALID_VALUE;
        EXPECT_FALSE(tbm_surface_internal_is_valid((tbm_surface_h)&invalid_surface));
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
@@ -166,11 +166,10 @@ TEST_F(TBMSurfaceInternal, GetBoFailNULL)
 
 TEST_F(TBMSurfaceInternal, GetBoFailInvalideInput)
 {
-       tbm_surface_h invalide_surface = (tbm_surface_h)1;
        tbm_bo bo = NULL;
 
        /* invalid surface */
-       bo = tbm_surface_internal_get_bo(invalide_surface, 0);
+       bo = tbm_surface_internal_get_bo(invalid_surface, 0);
        EXPECT_EQ(nullptr, bo);
        EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));