/* tbm_bo_alloc() */
-TEST_P(TBMBo, BoAllocUnref)
+TEST_F(TBMBo, BoAllocUnref)
{
tbm_bo bo;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoAllocWithBufmgrParamTest)
+TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
{
tbm_bo bo;
tbm_bufmgr invalid_bufmgr;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoAllocWithSizeParamTest)
+TEST_F(TBMBo, BoAllocWithSizeParamTest)
{
tbm_bo bo;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoAllocWithFlagsParamTest)
+TEST_F(TBMBo, BoAllocWithFlagsParamTest)
{
tbm_bo bo;
/* tbm_bo_ref() */
-TEST_P(TBMBo, BoRef)
+TEST_F(TBMBo, BoRef)
{
tbm_bo bo;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoRefWithBoParamTest)
+TEST_F(TBMBo, BoRefWithBoParamTest)
{
tbm_bo bo, invalid_bo;
/* tbm_bo_unref() */
-TEST_P(TBMBo, BoUnrefWithBoParamTest)
+TEST_F(TBMBo, BoUnrefWithBoParamTest)
{
tbm_bo invalid_bo;
/* tbm_bo_map() */
-TEST_P(TBMBo, BoMapUnmap)
+TEST_F(TBMBo, BoMapUnmap)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoMapWithBoParamTest)
+TEST_F(TBMBo, BoMapWithBoParamTest)
{
tbm_bo invalid_bo;
tbm_bo_handle bo_handle;
}
// TODO:: Use Value-Parameterized??
-TEST_P(TBMBo, BoMapWithDeviceParamTest)
+TEST_F(TBMBo, BoMapWithDeviceParamTest)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
}
// TODO:: Use Value-Parameterized??
-TEST_P(TBMBo, BoMapWithOptParamTest)
+TEST_F(TBMBo, BoMapWithOptParamTest)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
/* tbm_bo_unmap() */
-TEST_P(TBMBo, BoUnmapWithBoParamTest)
+TEST_F(TBMBo, BoUnmapWithBoParamTest)
{
tbm_bo bo;
tbm_bo invalid_bo;
/* tbm_bo_get_handle() */
-TEST_P(TBMBo, BoGetHandle)
+TEST_F(TBMBo, BoGetHandle)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoGetHandleWithBoParamTest)
+TEST_F(TBMBo, BoGetHandleWithBoParamTest)
{
tbm_bo_handle bo_handle;
tbm_bo invalid_bo;
ASSERT_TRUE(bo_handle.ptr == NULL);
}
-TEST_P(TBMBo, BoGetHandleWithDeviceParamTest)
+TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
/* tbm_bo_export() */
-TEST_P(TBMBo, BoExport)
+TEST_F(TBMBo, BoExport)
{
tbm_bo bo;
tbm_key bo_key;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoExportWithBoParamTest)
+TEST_F(TBMBo, BoExportWithBoParamTest)
{
tbm_bo invalid_bo;
tbm_key bo_key;
/* tbm_bo_export_fd() */
-TEST_P(TBMBo, BoExportFd)
+TEST_F(TBMBo, BoExportFd)
{
tbm_bo bo;
tbm_fd bo_fd;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoExportFdWithBoParamTest)
+TEST_F(TBMBo, BoExportFdWithBoParamTest)
{
tbm_bo invalid_bo;
tbm_fd bo_fd;
/* tbm_bo_import() */
-TEST_P(TBMBo, BoImport)
+TEST_F(TBMBo, BoImport)
{
tbm_bo bo1, bo2;
tbm_key bo_key;
tbm_bo_unref(bo1);
}
-TEST_P(TBMBo, BoImportWithBufmgrParamTest)
+TEST_F(TBMBo, BoImportWithBufmgrParamTest)
{
tbm_bufmgr invalid_bufmgr;
tbm_bo bo;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoImportWithKeyParamTest)
+TEST_F(TBMBo, BoImportWithKeyParamTest)
{
tbm_bo bo;
tbm_key bo_key_invalid;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoImportTwice)
+TEST_F(TBMBo, BoImportTwice)
{
tbm_bo bo1, bo2, bo3;
tbm_key bo_key;
/* tbm_bo_import_fd() */
-TEST_P(TBMBo, BoImportFd)
+TEST_F(TBMBo, BoImportFd)
{
tbm_bo bo1, bo2;
tbm_fd bo_fd;
tbm_bo_unref(bo1);
}
-TEST_P(TBMBo, BoImportFdWithBufmgrParamTest)
+TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
{
tbm_bufmgr invalid_bufmgr;
tbm_bo bo;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoImportFdWithFdParamTest)
+TEST_F(TBMBo, BoImportFdWithFdParamTest)
{
tbm_bo bo;
tbm_fd bo_fd_invalid;
ASSERT_TRUE(bo == NULL);
}
-TEST_P(TBMBo, BoImportFdTwice)
+TEST_F(TBMBo, BoImportFdTwice)
{
tbm_bo bo1, bo2, bo3;
tbm_fd bo_fd;
/* tbm_bo_size() */
-TEST_P(TBMBo, BoSize)
+TEST_F(TBMBo, BoSize)
{
tbm_bo bo;
int size = 0;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoSizeWithBoParamTest)
+TEST_F(TBMBo, BoSizeWithBoParamTest)
{
tbm_bo invalid_bo;
int size = 0;
/* tbm_bo_locked() */
-TEST_P(TBMBo, BoLocked)
+TEST_F(TBMBo, BoLocked)
{
tbm_bo bo;
tbm_bo_handle bo_handle;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoLockedWithBoParamTest)
+TEST_F(TBMBo, BoLockedWithBoParamTest)
{
tbm_bo invalid_bo;
int ret;
}
#if 0
-TEST_P(TBMBo, BoLockedOnce)
+TEST_F(TBMBo, BoLockedOnce)
{
// TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
tbm_bo_handle bo_handle1, bo_handle2;
ASSERT_EQ(ret_locked, 0);
}
-TEST_P(TBMBo, BoLockedAlways)
+TEST_F(TBMBo, BoLockedAlways)
{
// TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
tbm_bo_handle bo_handle1, bo_handle2;
ASSERT_EQ(ret_locked, 1);
}
-TEST_P(TBMBo, BoLockedNone)
+TEST_F(TBMBo, BoLockedNone)
{
// TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
tbm_bo_handle bo_handle1;
/* tbm_bo_swap() */
-TEST_P(TBMBo, BoSwap)
+TEST_F(TBMBo, BoSwap)
{
tbm_bo bo1, bo2;
int ret;
tbm_bo_unref(bo2);
}
-TEST_P(TBMBo, BoSwapWithBo1Bo2ParamTest)
+TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
{
tbm_bo bo, invalid_bo1, invalid_bo2;
int ret;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoSwapWithDifferentSizedBos)
+TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
{
tbm_bo bo1, bo2;
int ret;
/* tbm_bo_add_user_data() */
-TEST_P(TBMBo, BoAddUserData)
+TEST_F(TBMBo, BoAddUserData)
{
tbm_bo bo;
int ret;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoAddUserDataWithBoParamTest)
+TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
{
tbm_bo invalid_bo;
int ret;
ASSERT_TRUE(ret == 0);
}
-TEST_P(TBMBo, BoAddUserDataSameKeyTwiceTest)
+TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
{
tbm_bo bo;
int ret;
/* tbm_bo_delete_user_data() */
-TEST_P(TBMBo, BoDeleteUserData)
+TEST_F(TBMBo, BoDeleteUserData)
{
tbm_bo bo;
int ret;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoDeleteUserDataWithBoParam)
+TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
{
tbm_bo invalid_bo;
int ret;
ASSERT_TRUE(ret == 0);
}
-TEST_P(TBMBo, BoDeleteUserDataWithKeyParam)
+TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
{
tbm_bo bo;
int ret;
*i = 1;
}
-TEST_P(TBMBo, BoSetUserData)
+TEST_F(TBMBo, BoSetUserData)
{
tbm_bo bo;
unsigned long key = 4887;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoSetUserDataWithBoParamTest)
+TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
{
tbm_bo invalid_bo;
unsigned long key = 4887;
ASSERT_TRUE(ret == 0);
}
-TEST_P(TBMBo, BoSetUserDataWithKeyParamTest)
+TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
{
tbm_bo bo;
unsigned long key = 4887;
/* tbm_bo_get_user_data() */
-TEST_P(TBMBo, BoGetUserData)
+TEST_F(TBMBo, BoGetUserData)
{
tbm_bo bo;
unsigned long key = 4887;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoGetUserDataWithBoParamTest)
+TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
{
tbm_bo invalid_bo;
unsigned long key = 4887;
ASSERT_TRUE(ret == 0);
}
-TEST_P(TBMBo, BoGetUserDataWithKeyParamTest)
+TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
{
tbm_bo bo;
unsigned long key = 4887;
/* tbm_bo_get_flags() */
-TEST_P(TBMBo, BoGetFlags)
+TEST_F(TBMBo, BoGetFlags)
{
tbm_bo bo;
int flags1 = TBM_BO_DEFAULT, flags2 = -1;
tbm_bo_unref(bo);
}
-TEST_P(TBMBo, BoGetFlagsWithBoParamTest)
+TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
{
tbm_bo invalid_bo;
int flags = -1;
}
/* tbm_bufmgr_get_capability() */
-TEST_P(TBMBufmgr, BufmgrGetCapability)
+TEST_F(TBMBufmgr, BufmgrGetCapability)
{
unsigned int capability;
EXPECT_NE(capability, TBM_BUFMGR_CAPABILITY_NONE);
}
-TEST_P(TBMBufmgr, BufmgrGetCapabilityWithNullBufmgr)
+TEST_F(TBMBufmgr, BufmgrGetCapabilityWithNullBufmgr)
{
unsigned int capability;
EXPECT_EQ(capability, TBM_BUFMGR_CAPABILITY_NONE);
}
-TEST_P(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
+TEST_F(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
{
tbm_bufmgr bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
unsigned int capability;
/* tbm_bufmgr_bind_native_display() */
#if 0 // TDDO:: fix the crash...
-TEST_P(TBMBufmgr, BufmgrBindNativeDisplay)
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplay)
{
int ret;
void *native_display = (void *)UT_TBM_INVALID_VALUE;
ASSERT_EQ(ret, 1);
}
-TEST_P(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
{
int ret;
void *native_display = (void *)UT_TBM_INVALID_VALUE;
ASSERT_EQ(ret, 0);
}
-TEST_P(TBMBufmgr, BufmgrBindNativeDisplayWithWrongBufmgr)
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithWrongBufmgr)
{
int ret;
void *native_display = (void *)UT_TBM_INVALID_VALUE;
#endif
/* tbm_bufmgr_set_bo_lock_type() */
-TEST_P(TBMBufmgr, BufmgrSetBoLockType)
+TEST_F(TBMBufmgr, BufmgrSetBoLockType)
{
int ret;
ASSERT_TRUE(ret == 1);
}
-TEST_P(TBMBufmgr, BufmgrSetBoLockTypeWithBufmgrParamTest)
+TEST_F(TBMBufmgr, BufmgrSetBoLockTypeWithBufmgrParamTest)
{
tbm_bufmgr invalid_bufmgr;
int ret;