From 985dba76b071e4a804ad59624f1e8f0dd70045dc Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Fri, 11 Jun 2021 16:27:25 +0900 Subject: [PATCH] tc: fix the prefix of the definition in tc_tbm.h Change-Id: If82a337d08ddc8a632a40679e7feaa13f8cf4a7a --- haltests/tc_tbm.h | 6 +-- haltests/tc_tbm_bo.cpp | 78 +++++++++++++-------------- haltests/tc_tbm_bufmgr.cpp | 8 +-- haltests/tc_tbm_log.cpp | 2 +- haltests/tc_tbm_surface_queue.cpp | 108 +++++++++++++++++++------------------- 5 files changed, 101 insertions(+), 101 deletions(-) diff --git a/haltests/tc_tbm.h b/haltests/tc_tbm.h index f4e05dd..21b703d 100644 --- 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 --- 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 --- 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 --- 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 --- 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( -- 2.7.4