utest: check the tbm_error_e for the bo tests

Change-Id: I1fa5abfb0509c4619c9cf5b3f4986cf10c06c63d

diff --git a/utests/ut_tbm_bo.cpp b/utests/ut_tbm_bo.cpp
index e01ef08..5cdf951 100644 (file)
--- a/utests/ut_tbm_bo.cpp
+++ b/utests/ut_tbm_bo.cpp
@@ -51,7 +51,7 @@ void TBMBo::SetUp()
        TBMBufmgr::SetUp();
 
        bufmgr_capability = tbm_bufmgr_get_capability(bufmgr);
-       ASSERT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
+       EXPECT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
 }
 
 void TBMBo::TearDown()
@@ -66,7 +66,9 @@ TEST_F(TBMBo, BoAllocUnref)
        tbm_bo bo;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo);
 }
 
@@ -77,11 +79,13 @@ TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
 
        invalid_bufmgr = NULL;
        bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo == NULL);
+       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);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoAllocWithSizeParamTest)
@@ -89,7 +93,8 @@ TEST_F(TBMBo, BoAllocWithSizeParamTest)
        tbm_bo bo;
 
        bo = tbm_bo_alloc(bufmgr, -1, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoAllocWithFlagsParamTest)
@@ -97,19 +102,23 @@ TEST_F(TBMBo, BoAllocWithFlagsParamTest)
        tbm_bo bo;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
 }
 
@@ -120,10 +129,12 @@ TEST_F(TBMBo, BoRef)
        tbm_bo bo;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo = tbm_bo_ref(bo);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
        tbm_bo_unref(bo);
@@ -134,11 +145,13 @@ TEST_F(TBMBo, BoRefWithBoParamTest)
        tbm_bo bo, invalid_bo;
 
        bo = tbm_bo_ref(NULL);
-       ASSERT_TRUE(bo == 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);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_bo_unref() */
@@ -148,11 +161,11 @@ 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);
-
-       SUCCEED();
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_bo_map() */
@@ -162,20 +175,18 @@ TEST_F(TBMBo, BoMapUnmap)
        tbm_bo bo;
        tbm_bo_handle bo_handle;
        int ret;
-       tbm_error_e error;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
-       error = tbm_get_last_error();
-       EXPECT_TRUE(error != TBM_BO_ERROR_LOCK_FAILED);
-       error = tbm_get_last_error();
-       EXPECT_TRUE(error != TBM_BO_ERROR_MAP_FAILED);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
 }
@@ -186,11 +197,13 @@ TEST_F(TBMBo, BoMapWithBoParamTest)
        tbm_bo_handle bo_handle;
 
        bo_handle = tbm_bo_map(NULL, TBM_DEVICE_CPU, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr == NULL);
+       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);
-       ASSERT_TRUE(bo_handle.ptr == NULL);
+       EXPECT_EQ(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 // TODO:: Use Value-Parameterized??
@@ -201,34 +214,43 @@ TEST_F(TBMBo, BoMapWithDeviceParamTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_DEFAULT, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_3D, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
 #if 0
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_MM, TBM_OPTION_READ);
        if (!bo_handle.ptr)
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
 #endif
 
        tbm_bo_unref(bo);
@@ -242,22 +264,29 @@ TEST_F(TBMBo, BoMapWithOptParamTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ|TBM_OPTION_WRITE);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
 }
@@ -271,18 +300,22 @@ TEST_F(TBMBo, BoUnmapWithBoParamTest)
        int ret;
 
        ret = tbm_bo_unmap(NULL);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(ret == 0);
-       tbm_bo_unref(bo);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
+       tbm_bo_unref(bo);
 }
 
 /* tbm_bo_get_handle() */
@@ -293,9 +326,11 @@ TEST_F(TBMBo, BoGetHandle)
        tbm_bo_handle bo_handle;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_bo_unref(bo);
 }
 
@@ -305,11 +340,13 @@ TEST_F(TBMBo, BoGetHandleWithBoParamTest)
        tbm_bo invalid_bo;
 
        bo_handle = tbm_bo_get_handle(NULL, TBM_DEVICE_DEFAULT);
-       ASSERT_TRUE(bo_handle.ptr == NULL);
+       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);
-       ASSERT_TRUE(bo_handle.ptr == NULL);
+       EXPECT_EQ(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
@@ -318,23 +355,28 @@ TEST_F(TBMBo, BoGetHandleWithDeviceParamTest)
        tbm_bo_handle bo_handle;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       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_DEFAULT);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, 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);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, 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_2D);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, 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_3D);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
 #if 0
        bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_MM);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
 #endif
 
        tbm_bo_unref(bo);
@@ -351,12 +393,15 @@ TEST_F(TBMBo, BoExport)
                return;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_key = tbm_bo_export(bo);
-       ASSERT_TRUE(bo_key != 0);
+       EXPECT_GT(bo_key, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoExportWithBoParamTest)
@@ -368,11 +413,13 @@ TEST_F(TBMBo, BoExportWithBoParamTest)
                return;
 
        bo_key = tbm_bo_export(NULL);
-       ASSERT_TRUE(bo_key == 0);
+       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);
-       ASSERT_TRUE(bo_key == 0);
+       EXPECT_EQ(bo_key, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_bo_export_fd() */
@@ -386,12 +433,15 @@ TEST_F(TBMBo, BoExportFd)
                return;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_fd = tbm_bo_export_fd(bo);
-       ASSERT_TRUE(bo_fd != 0);
+       EXPECT_GT(bo_fd, -1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoExportFdWithBoParamTest)
@@ -403,11 +453,13 @@ TEST_F(TBMBo, BoExportFdWithBoParamTest)
                return;
 
        bo_fd = tbm_bo_export_fd(NULL);
-       ASSERT_TRUE(bo_fd == -1);
+       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);
-       ASSERT_TRUE(bo_fd == -1);
+       EXPECT_EQ(bo_fd, -1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_bo_import() */
@@ -421,16 +473,22 @@ TEST_F(TBMBo, BoImport)
                return;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo1 != NULL);
+       EXPECT_NE(bo1, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_key = tbm_bo_export(bo1);
-       ASSERT_TRUE(bo_key != 0);
+       EXPECT_GT(bo_key, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo2 = tbm_bo_import(bufmgr, bo_key);
-       ASSERT_TRUE(bo2 != NULL);
+       EXPECT_NE(bo2, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoImportWithBufmgrParamTest)
@@ -443,11 +501,13 @@ TEST_F(TBMBo, BoImportWithBufmgrParamTest)
                return;
 
        bo = tbm_bo_import(NULL, bo_key);
-       ASSERT_TRUE(bo == NULL);
+       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);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoImportWithKeyParamTest)
@@ -460,7 +520,8 @@ TEST_F(TBMBo, BoImportWithKeyParamTest)
 
        bo_key_invalid = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
        bo = tbm_bo_import(bufmgr, bo_key_invalid);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoImportTwice)
@@ -472,20 +533,29 @@ TEST_F(TBMBo, BoImportTwice)
                return;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo1 != NULL);
+       EXPECT_NE(bo1, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_key = tbm_bo_export(bo1);
-       ASSERT_TRUE(bo_key != 0);
+       EXPECT_GT(bo_key, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo2 = tbm_bo_import(bufmgr, bo_key);
-       ASSERT_TRUE(bo2 != NULL);
+       EXPECT_NE(bo2, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo3 = tbm_bo_import(bufmgr, bo_key);
-       ASSERT_TRUE(bo3 != NULL);
+       EXPECT_NE(bo3, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo3);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_import_fd() */
@@ -499,16 +569,22 @@ TEST_F(TBMBo, BoImportFd)
                return;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo1 != NULL);
+       EXPECT_NE(bo1, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_fd = tbm_bo_export_fd(bo1);
-       ASSERT_TRUE(bo_fd != 0);
+       EXPECT_GT(bo_fd, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo2 = tbm_bo_import_fd(bufmgr, bo_fd);
-       ASSERT_TRUE(bo2 != NULL);
+       EXPECT_NE(bo2, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
@@ -521,11 +597,13 @@ TEST_F(TBMBo, BoImportFdWithBufmgrParamTest)
                return;
 
        bo = tbm_bo_import_fd(NULL, bo_fd);
-       ASSERT_TRUE(bo == NULL);
+       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);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoImportFdWithFdParamTest)
@@ -538,7 +616,8 @@ TEST_F(TBMBo, BoImportFdWithFdParamTest)
 
        bo_fd_invalid = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
        bo = tbm_bo_import_fd(bufmgr, bo_fd_invalid);
-       ASSERT_TRUE(bo == NULL);
+       EXPECT_EQ(bo, nullptr);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoImportFdTwice)
@@ -550,20 +629,29 @@ TEST_F(TBMBo, BoImportFdTwice)
                return;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo1 != NULL);
+       EXPECT_NE(bo1, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_fd = tbm_bo_export_fd(bo1);
-       ASSERT_TRUE(bo_fd != 0);
+       EXPECT_GT(bo_fd, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo2 = tbm_bo_import_fd(bufmgr, bo_fd);
-       ASSERT_TRUE(bo2 != NULL);
+       EXPECT_NE(bo2, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo3 = tbm_bo_import_fd(bufmgr, bo_fd);
-       ASSERT_TRUE(bo3 != NULL);
+       EXPECT_NE(bo3, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo3);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_size() */
@@ -574,12 +662,15 @@ TEST_F(TBMBo, BoSize)
        int size = 0;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        size = tbm_bo_size(bo);
-       ASSERT_TRUE(size != 0);
+       EXPECT_GT(size, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoSizeWithBoParamTest)
@@ -588,11 +679,13 @@ TEST_F(TBMBo, BoSizeWithBoParamTest)
        int size = 0;
 
        size = tbm_bo_size(NULL);
-       ASSERT_TRUE(size == 0);
+       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);
-       ASSERT_TRUE(size == 0);
+       EXPECT_EQ(size, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_bo_locked() */
@@ -604,27 +697,34 @@ TEST_F(TBMBo, BoLocked)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* unlocked */
        ret = tbm_bo_locked(bo);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
-       ASSERT_TRUE(bo_handle.ptr != NULL);
+       EXPECT_NE(bo_handle.ptr, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* locked */
        ret = tbm_bo_locked(bo);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_unmap(bo);
-       ASSERT_TRUE(ret != 0);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* unlocked */
        ret = tbm_bo_locked(bo);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoLockedWithBoParamTest)
@@ -633,11 +733,13 @@ TEST_F(TBMBo, BoLockedWithBoParamTest)
        int ret;
 
        ret = tbm_bo_locked(NULL);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 #if 0
@@ -651,7 +753,7 @@ TEST_F(TBMBo, BoLockedOnce)
        setenv("BUFMGR_LOCK_TYPE", "once", 1);
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, bo);
+       EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
        bo_handle2 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
@@ -664,7 +766,7 @@ TEST_F(TBMBo, BoLockedOnce)
 
        tbm_bo_unmap(bo);
 
-       ASSERT_EQ(ret_locked, 0);
+       EXPECT_EQ(ret_locked, 0);
 }
 
 TEST_F(TBMBo, BoLockedAlways)
@@ -677,7 +779,7 @@ TEST_F(TBMBo, BoLockedAlways)
        setenv("BUFMGR_LOCK_TYPE", "always", 1);
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, bo);
+       EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
        bo_handle2 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
@@ -690,7 +792,7 @@ TEST_F(TBMBo, BoLockedAlways)
 
        tbm_bo_unmap(bo);
 
-       ASSERT_EQ(ret_locked, 1);
+       EXPECT_EQ(ret_locked, 1);
 }
 
 TEST_F(TBMBo, BoLockedNone)
@@ -703,7 +805,7 @@ TEST_F(TBMBo, BoLockedNone)
        setenv("BUFMGR_LOCK_TYPE", "none", 1);
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, bo);
+       EXPECT_NE(nullptr, bo);
 
        bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
        (void) bo_handle1;
@@ -712,7 +814,7 @@ TEST_F(TBMBo, BoLockedNone)
 
        tbm_bo_unmap(bo);
 
-       ASSERT_EQ(ret_locked, 0);
+       EXPECT_EQ(ret_locked, 0);
 }
 #endif
 
@@ -724,16 +826,22 @@ TEST_F(TBMBo, BoSwap)
        int ret;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo1 != NULL);
+       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);
-       ASSERT_TRUE(bo2 != NULL);
+       EXPECT_NE(bo2, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_swap(bo1, bo2);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
@@ -742,52 +850,64 @@ TEST_F(TBMBo, BoSwapWithBo1Bo2ParamTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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, NULL);
-       ASSERT_TRUE(ret == 0);
+       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, bo);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoSwapWithDifferentSizedBos)
 {
        tbm_bo bo1, bo2;
        int ret;
-       tbm_error_e error;
 
        bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_NE(nullptr, bo1);
+       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);
-       ASSERT_NE(nullptr, bo2);
+       EXPECT_NE(nullptr, bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_swap(bo1, bo2);
-       error = tbm_get_last_error();
-
-       ASSERT_TRUE(ret == 0);
-       ASSERT_TRUE(error == TBM_BO_ERROR_SWAP_FAILED);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        tbm_bo_unref(bo1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_add_user_data() */
@@ -798,12 +918,15 @@ TEST_F(TBMBo, BoAddUserData)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
@@ -812,11 +935,13 @@ TEST_F(TBMBo, BoAddUserDataWithBoParamTest)
        int ret;
 
        ret = tbm_bo_add_user_data(NULL, 4887, NULL);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
@@ -825,15 +950,19 @@ TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_delete_user_data() */
@@ -844,15 +973,18 @@ TEST_F(TBMBo, BoDeleteUserData)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
 
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_delete_user_data(bo, 4887);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
@@ -861,11 +993,13 @@ TEST_F(TBMBo, BoDeleteUserDataWithBoParam)
        int ret;
 
        ret = tbm_bo_delete_user_data(NULL, 4887);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
@@ -874,19 +1008,24 @@ TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* no use_data in bo */
        ret = tbm_bo_delete_user_data(bo, 4887);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        /* delete the data with the wrong key */
        ret = tbm_bo_add_user_data(bo, 4887, NULL);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        ret = tbm_bo_delete_user_data(bo, 4887 + 10);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_set_user_data() */
@@ -906,22 +1045,29 @@ TEST_F(TBMBo, BoSetUserData)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_set_user_data(bo, key, &data1);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
        ret = tbm_bo_set_user_data(bo, key, &data2);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_delete_user_data(bo, key);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_TRUE(data1 == 1);
+       EXPECT_TRUE(data1 == 1);
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
@@ -932,11 +1078,13 @@ TEST_F(TBMBo, BoSetUserDataWithBoParamTest)
        int ret;
 
        ret = tbm_bo_set_user_data(NULL, key, &data1);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
@@ -947,23 +1095,29 @@ TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* no add_user_data */
        ret = tbm_bo_set_user_data(bo, 4887, &data);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* with non-existed key */
        ret = tbm_bo_set_user_data(bo, key + 10, &data);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        ret = tbm_bo_delete_user_data(bo, key);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_get_user_data() */
@@ -977,23 +1131,29 @@ TEST_F(TBMBo, BoGetUserData)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_add_user_data(bo, key, NULL);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_set_user_data(bo, key, &data1);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* success */
        ret = tbm_bo_get_user_data(bo, key, (void **)&data2);
-       ASSERT_TRUE(ret == 1);
-       ASSERT_TRUE(data2 == &data1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_TRUE(data2 == &data1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        ret = tbm_bo_delete_user_data(bo, key);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
@@ -1005,11 +1165,13 @@ TEST_F(TBMBo, BoGetUserDataWithBoParamTest)
        int ret;
 
        ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
-       ASSERT_TRUE(ret == 0);
+       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);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
@@ -1020,27 +1182,34 @@ TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
        int ret;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* no add_user_data/set_user_data */
        ret = tbm_bo_get_user_data(bo, 4887, (void **)&data);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* with non-existed key */
        ret = tbm_bo_get_user_data(bo, key + 10, (void **)&data);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        ret = tbm_bo_delete_user_data(bo, key);
-       ASSERT_TRUE(ret == 1);
+       EXPECT_EQ(ret, 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* removed data */
        ret = tbm_bo_get_user_data(bo, key, (void **)&data);
-       ASSERT_TRUE(ret == 0);
+       EXPECT_EQ(ret, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo_get_flags() */
@@ -1051,12 +1220,15 @@ TEST_F(TBMBo, BoGetFlags)
        int flags1 = TBM_BO_DEFAULT, flags2 = -1;
 
        bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
-       ASSERT_TRUE(bo != NULL);
+       EXPECT_NE(bo, nullptr);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        flags2 = tbm_bo_get_flags(bo);
-       ASSERT_TRUE(flags1 == flags2);
+       EXPECT_TRUE(flags1 == flags2);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_bo_unref(bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
@@ -1065,11 +1237,13 @@ TEST_F(TBMBo, BoGetFlagsWithBoParamTest)
        int flags = -1;
 
        flags = tbm_bo_get_flags(NULL);
-       ASSERT_TRUE(flags == 0);
+       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);
-       ASSERT_TRUE(flags == 0);
+       EXPECT_TRUE(flags == 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 INSTANTIATE_TEST_CASE_P(TBMBoParams,