utest: check the tbm_error_e for the surface_internal tests

Change-Id: Ie5e76690e3c7dc91a8f4f63dc6ba7e8a52acc0ae

diff --git a/utests/ut_tbm_surface_internal.cpp b/utests/ut_tbm_surface_internal.cpp
index 6f47ab3..da12fe5 100644 (file)
--- a/utests/ut_tbm_surface_internal.cpp
+++ b/utests/ut_tbm_surface_internal.cpp
@@ -81,9 +81,10 @@ TEST_F(TBMSurfaceInternal, SurfaceInternalCeateDestroyTest)
 
        for (uint32_t i = 0; i < 1; i++) {
                surface1 = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
-               ASSERT_TRUE(surface1 != NULL);
+               EXPECT_NE(surface1, nullptr);
+               EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
                tbm_surface_internal_destroy(surface1);
-               printf("!!!!!!!!!!!!!![soolim]: refcnt=%d\n", tbm_bufmgr_debug_get_ref_count());
+               EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        }
 }
 
@@ -92,19 +93,24 @@ TEST_F(TBMSurfaceInternal, SurfaceInternalCeatewithParamsTest)
        tbm_surface_h surface1 = NULL;
 
        surface1 = tbm_surface_internal_create_with_flags(-1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, surface1); // Expected Value: NULL
+       EXPECT_EQ(nullptr, surface1); // Expected Value: NULL
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
        surface1 = tbm_surface_internal_create_with_flags(720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, surface1);
+       EXPECT_EQ(nullptr, surface1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
        surface1 = tbm_surface_internal_create_with_flags(720, 1024, 0, TBM_BO_DEFAULT);
-       ASSERT_EQ(nullptr, surface1);
+       EXPECT_EQ(nullptr, surface1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
        surface1 = tbm_surface_internal_create_with_flags(720, 1024, 0, (TBM_BO_WC << 1));
-       ASSERT_EQ(nullptr, surface1);
+       EXPECT_EQ(nullptr, surface1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* void tbm_surface_internal_destroy(tbm_surface_h surface) */
 TEST_F(TBMSurfaceInternal, SurfaceInternalSurfaceInteranlDestroyWithParamsTest)
 {
        tbm_surface_internal_destroy(NULL);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, SurfaceInteranlDestroyTwiceTest)
@@ -112,8 +118,11 @@ TEST_F(TBMSurfaceInternal, SurfaceInteranlDestroyTwiceTest)
        tbm_surface_h surface1 = NULL;
 
        surface1 = tbm_surface_internal_create_with_flags(720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surface1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surface1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_surface_internal_is_valid(tbm_surface_h surface) */
@@ -121,53 +130,54 @@ TEST_F(TBMSurfaceInternal, SurfaceInteranlIsValid)
 {
        tbm_surface_h invalid_surface;
 
-       ASSERT_TRUE(tbm_surface_internal_is_valid(surface));
-       tbm_surface_internal_destroy(surface);
+       EXPECT_TRUE(tbm_surface_internal_is_valid(surface));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_FALSE(tbm_surface_internal_is_valid(NULL));
+       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;
-       ASSERT_FALSE(tbm_surface_internal_is_valid((tbm_surface_h)&invalid_surface));
+       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));
 }
 
 /* int tbm_surface_internal_get_num_bos(tbm_surface_h surface) */
 TEST_F(TBMSurfaceInternal, GetNumBosFailNULL)
 {
        int num = tbm_surface_internal_get_num_bos(NULL);
-       ASSERT_EQ(0, num);
+       EXPECT_EQ(0, num);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetNumBosSuccess)
 {
        int num = tbm_surface_internal_get_num_bos(surface);
-       ASSERT_TRUE(num > 0);
+       EXPECT_GT(num, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_bo tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx) */
 TEST_F(TBMSurfaceInternal, GetBoFailNULL)
 {
        tbm_bo bo = tbm_surface_internal_get_bo(NULL, 0);
-       ASSERT_EQ(nullptr, bo);
+       EXPECT_EQ(nullptr, bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetBoFailInvalideInput)
 {
        tbm_surface_h invalide_surface = (tbm_surface_h)1;
        tbm_bo bo = NULL;
-       int num = 0;
 
        /* invalid surface */
        bo = tbm_surface_internal_get_bo(invalide_surface, 0);
-       ASSERT_EQ(nullptr, bo);
-
-       num = tbm_surface_internal_get_num_bos(surface);
-       ASSERT_TRUE(num > 0);
+       EXPECT_EQ(nullptr, bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        /* invalid index of bo */
        bo = tbm_surface_internal_get_bo(surface, -1);
-       ASSERT_EQ(nullptr, bo);
-       bo = tbm_surface_internal_get_bo(surface, num);
-       ASSERT_EQ(nullptr, bo);
+       EXPECT_EQ(nullptr, bo);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetBoSuccess)
@@ -176,11 +186,13 @@ TEST_F(TBMSurfaceInternal, GetBoSuccess)
        int num = 0;
 
        num = tbm_surface_internal_get_num_bos(surface);
-       ASSERT_TRUE(num > 0);
+       EXPECT_GT(num, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        for (int i = 0; i < num; i++) {
                bo = tbm_surface_internal_get_bo(surface, i);
-               ASSERT_NE((tbm_bo)NULL, bo);
+               EXPECT_NE(nullptr, bo);
+               EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        }
 }
 
@@ -193,15 +205,19 @@ TEST_F(TBMSurfaceInternal, CreateWithBosNullInput)
        tbm_bo bos[1];
 
        result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
-       ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
+       EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 
        surf = tbm_surface_internal_create_with_bos(NULL, NULL, 1);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        surf = tbm_surface_internal_create_with_bos(&info, NULL, 1);
-       ASSERT_EQ(nullptr, surf);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        surf = tbm_surface_internal_create_with_bos(NULL, bos, 1);
-       ASSERT_EQ(nullptr, surf);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, CreateWithBosFailInvalidInput)
@@ -213,27 +229,30 @@ TEST_F(TBMSurfaceInternal, CreateWithBosFailInvalidInput)
        int num;
 
        result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
-       ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
+       EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 
        num = tbm_surface_internal_get_num_bos(surface);
-       ASSERT_TRUE(num > 0);
+       EXPECT_GT(num, 0);
 
        for (int i = 0; i < num; i++) {
                bos[i] = tbm_surface_internal_get_bo(surface, i);
-               ASSERT_NE(nullptr, bos[i]);
+               EXPECT_NE(nullptr, bos[i]);
+               EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        }
 
-
        /* wrong number of bo */
        surf = tbm_surface_internal_create_with_bos(&info, bos, num + 1);
-       ASSERT_EQ(nullptr, surf);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        surf = tbm_surface_internal_create_with_bos(&info, bos, num - 1);
-       ASSERT_EQ(nullptr, surf);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* invalid bo */
        bos[num-1] = NULL;
        surf = tbm_surface_internal_create_with_bos(&info, bos, num);
-       ASSERT_EQ(nullptr, surf);
+       EXPECT_EQ(nullptr, surf);
+       EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMSurfaceInternal, CreateWithBosSuccess)
@@ -245,56 +264,70 @@ TEST_F(TBMSurfaceInternal, CreateWithBosSuccess)
        int num = 0;
 
        result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
-       ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result);
+       EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
+       EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
 
        num = tbm_surface_internal_get_num_bos(surface);
-       ASSERT_TRUE(num > 0);
+       EXPECT_GT(num , 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        for (int i = 0; i < num; i++) {
                bos[i] = tbm_surface_internal_get_bo(surface, i);
-               ASSERT_NE(nullptr, bos[i]);
+               EXPECT_NE(nullptr, bos[i]);
+               EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        }
 
        surf = tbm_surface_internal_create_with_bos(&info, bos, num);
-       ASSERT_NE(nullptr, surf);
+       EXPECT_NE(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* set size plane to zero*/
        info.planes[0].size = 0;
        surf = tbm_surface_internal_create_with_bos(&info, bos, num);
-       ASSERT_NE(nullptr, surf);
+       EXPECT_NE(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* set bpp to zero*/
        info.bpp = 0;
        surf = tbm_surface_internal_create_with_bos(&info, bos, num);
-       ASSERT_NE(nullptr, surf);
+       EXPECT_NE(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* set size to zero*/
        info.size = 0;
        surf = tbm_surface_internal_create_with_bos(&info, bos, num);
-       ASSERT_NE(nullptr, surf);
+       EXPECT_NE(nullptr, surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_destroy(surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* void tbm_surface_internal_unref(tbm_surface_h surface) */
 TEST_F(TBMSurfaceInternal, UnrefFailNull)
 {
        tbm_surface_internal_unref(NULL);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, UnrefFailInvaildInput)
 {
        int surf;
        tbm_surface_internal_unref((tbm_surface_h)&surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, UnrefSuccess)
 {
        tbm_surface_internal_unref(surface);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) ;
+       EXPECT_FALSE(tbm_surface_internal_is_valid(surface)) ;
 
        surface = NULL;
 }
@@ -303,19 +336,23 @@ TEST_F(TBMSurfaceInternal, UnrefSuccess)
 TEST_F(TBMSurfaceInternal, RefFailNull)
 {
        tbm_surface_internal_ref(NULL);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, RefFailInvaildInput)
 {
        int surf;
        tbm_surface_internal_ref((tbm_surface_h)&surf);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, RefSuccess)
 {
        tbm_surface_internal_ref(surface);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
        tbm_surface_internal_unref(surface);
-       ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) ;
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_TRUE(tbm_surface_internal_is_valid(surface));
 }
 
 /* tbm_surface_internal_get_num_planes() */
@@ -323,64 +360,78 @@ TEST_F(TBMSurfaceInternal, GetNumPlanes)
 {
        int num = 0;
        num = tbm_surface_internal_get_num_planes(0);
-       ASSERT_EQ(0, num);
+       EXPECT_EQ(0, num);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        num = tbm_surface_internal_get_num_planes(TBM_FORMAT_ARGB8888);
-       ASSERT_EQ(1, num);
+       EXPECT_EQ(1, num);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        num = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
-       ASSERT_EQ(2, num);
+       EXPECT_EQ(2, num);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        num = tbm_surface_internal_get_num_planes(TBM_FORMAT_YUV410);
-       ASSERT_EQ(3, num);
+       EXPECT_EQ(3, num);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_surface_internal_get_size() */
 TEST_F(TBMSurfaceInternal, GetSizeFailNull)
 {
        int size = tbm_surface_internal_get_size(NULL);
-       ASSERT_EQ(0, size);
+       EXPECT_EQ(0, size);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetSizeFailInvaildInput)
 {
        int surf;
        int size = tbm_surface_internal_get_size((tbm_surface_h)&surf);
-       ASSERT_EQ(0, size);
+       EXPECT_EQ(0, size);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetSizeSuccess)
 {
        int size = tbm_surface_internal_get_size(surface);
        ASSERT_GT(size, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_surface_internal_get_plane_data(tbm_surface_h surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch) */
 TEST_F(TBMSurfaceInternal, GetPlaneDataFailNull)
 {
-       ASSERT_FALSE(tbm_surface_internal_get_plane_data(NULL, 0, NULL, NULL, NULL));
+       EXPECT_FALSE(tbm_surface_internal_get_plane_data(NULL, 0, NULL, NULL, NULL));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetPlaneDataFailInvaildInput)
 {
        int surf;
 
-       ASSERT_FALSE(tbm_surface_internal_get_plane_data((tbm_surface_h)&surf, 0, NULL, NULL, NULL));
-       ASSERT_FALSE(tbm_surface_internal_get_plane_data(surface, -1, NULL, NULL, NULL));
-       ASSERT_FALSE(tbm_surface_internal_get_plane_data(surface, 3, NULL, NULL, NULL));
+       EXPECT_FALSE(tbm_surface_internal_get_plane_data((tbm_surface_h)&surf, 0, NULL, NULL, NULL));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+       EXPECT_FALSE(tbm_surface_internal_get_plane_data(surface, -1, NULL, NULL, NULL));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+       EXPECT_FALSE(tbm_surface_internal_get_plane_data(surface, 3, NULL, NULL, NULL));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetPlaneDataSuccess)
 {
        uint32_t size = 0, offset = 0, pitch = 0;
 
-       ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, &size, NULL, NULL));
-       ASSERT_GT(size, 0);
+       EXPECT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, &size, NULL, NULL));
+       EXPECT_GT(size, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, &offset, NULL));
+       EXPECT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, &offset, NULL));
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, NULL, &pitch));
-       ASSERT_GT(pitch, 0);
+       EXPECT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, NULL, &pitch));
+       EXPECT_GT(pitch, 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 /* tbm_surface_internal_get_bpp(tbm_format format) */
@@ -388,43 +439,55 @@ TEST_F(TBMSurfaceInternal, GetBpp)
 {
        int bpp = 0;
        bpp = tbm_surface_internal_get_bpp(0);
-       ASSERT_EQ(0, bpp);
+       EXPECT_EQ(0, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB332);
-       ASSERT_EQ(8, bpp);
+       EXPECT_EQ(8, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB565);
-       ASSERT_EQ(16, bpp);
+       EXPECT_EQ(16, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB888);
-       ASSERT_EQ(24, bpp);
+       EXPECT_EQ(24, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_ARGB8888);
-       ASSERT_EQ(32, bpp);
+       EXPECT_EQ(32, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
-       ASSERT_EQ(12, bpp);
+       EXPECT_EQ(12, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV16);
-       ASSERT_EQ(16, bpp);
+       EXPECT_EQ(16, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV410);
-       ASSERT_EQ(9, bpp);
+       EXPECT_EQ(9, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV411);
-       ASSERT_EQ(12, bpp);
+       EXPECT_EQ(12, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV422);
-       ASSERT_EQ(16, bpp);
+       EXPECT_EQ(16, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV444);
-       ASSERT_EQ(24, bpp);
+       EXPECT_EQ(24, bpp);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 /* tbm_surface_internal_get_plane_bo_idx(tbm_surface_h surface, int plane_idx) */
 TEST_F(TBMSurfaceInternal, GetPlaneBoIndexFailNull)
 {
        int idx = tbm_surface_internal_get_plane_bo_idx(NULL, 0);
-       ASSERT_EQ(0, idx);
+       EXPECT_EQ(0, idx);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetPlaneBoIndexFailInvaildInput)
@@ -433,10 +496,12 @@ TEST_F(TBMSurfaceInternal, GetPlaneBoIndexFailInvaildInput)
        int idx;
 
        idx = tbm_surface_internal_get_plane_bo_idx((tbm_surface_h)&surf, 0);
-       ASSERT_EQ(0, idx);
+       EXPECT_EQ(0, idx);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
        idx = tbm_surface_internal_get_plane_bo_idx(surface, -1);
-       ASSERT_EQ(0, idx);
+       EXPECT_EQ(0, idx);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetPlaneBoIndexSuccess)
@@ -444,7 +509,8 @@ TEST_F(TBMSurfaceInternal, GetPlaneBoIndexSuccess)
        int idx;
 
        idx = tbm_surface_internal_get_plane_bo_idx(surface, 0);
-       ASSERT_EQ(0, idx);
+       EXPECT_EQ(0, idx);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 static int tbm_data_free_is_called = 0;
@@ -459,35 +525,41 @@ void data_free_handle(void *user_data)
 TEST_F(TBMSurfaceInternal, AddUserDataFailNull)
 {
        static const unsigned long key_ud = 0;
-       ASSERT_FALSE(tbm_surface_internal_add_user_data(NULL, key_ud, NULL));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(NULL, key_ud, NULL), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, AddUserDataFailInvaildInput)
 {
        static const unsigned long key_ud = 0;
-       int surf;
-       ASSERT_FALSE(tbm_surface_internal_add_user_data((tbm_surface_h)&surf, key_ud, NULL));
+       int invalid_surf;
+       EXPECT_EQ(tbm_surface_internal_add_user_data((tbm_surface_h)&invalid_surf, key_ud, NULL), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, AddUserDataSuccess)
 {
        unsigned long key_ud = 157;
-       ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, NULL), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 }
 
 TEST_F(TBMSurfaceInternal, AddUserDataFailDoubleKey)
 {
        unsigned long key_ud = 5487;
-       ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, NULL), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
-       ASSERT_FALSE(tbm_surface_internal_add_user_data(surface, key_ud, NULL));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, NULL), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 /* tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key, void *data) */
 TEST_F(TBMSurfaceInternal, SetUserDataFailNull)
 {
        static const unsigned long key_ud = 0;
-       ASSERT_FALSE(tbm_surface_internal_set_user_data(NULL, key_ud, &tbm_data_free_is_called));
+       EXPECT_EQ(tbm_surface_internal_set_user_data(NULL, key_ud, &tbm_data_free_is_called), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, SetUserDataFailInvaildInput)
@@ -495,31 +567,36 @@ TEST_F(TBMSurfaceInternal, SetUserDataFailInvaildInput)
        static const unsigned long key_ud = 0;
        int surf;
 
-       ASSERT_FALSE(tbm_surface_internal_set_user_data(surface,
-                       key_ud, &tbm_data_free_is_called)) << "invalid key";
-
-       ASSERT_FALSE(tbm_surface_internal_set_user_data((tbm_surface_h)&surf,
-                       key_ud, &tbm_data_free_is_called)) << "invalid surface";
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface,
+                       key_ud, &tbm_data_free_is_called), 0) << "invalid key";
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
+       EXPECT_EQ(tbm_surface_internal_set_user_data((tbm_surface_h)&surf,
+                       key_ud, &tbm_data_free_is_called), 0) << "invalid surface";
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, SetUserDataSuccess)
 {
        unsigned long key_ud = 87947;
-       ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /*the first call*/
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /*the second call: previous data has to be released*/
        tbm_data_free_is_called = 0;
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
-       ASSERT_TRUE(tbm_data_free_is_called);
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, NULL), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_data_free_is_called, 1);
 
        /*the third call: previous data(NULL) hasn't to be released*/
        tbm_data_free_is_called = 0;
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
-       ASSERT_FALSE(tbm_data_free_is_called);
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, NULL), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_data_free_is_called, 0);
 }
 
 /* tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key, void **data) */
@@ -527,9 +604,11 @@ TEST_F(TBMSurfaceInternal, GetUserDataFailNull)
 {
        static const unsigned long key_ud = 0;
        int *data = NULL;
-       ASSERT_FALSE(tbm_surface_internal_get_user_data(NULL, key_ud, (void **)&data));
+       EXPECT_EQ(tbm_surface_internal_get_user_data(NULL, key_ud, (void **)&data), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       ASSERT_FALSE(tbm_surface_internal_get_user_data(surface, key_ud, NULL));
+       EXPECT_EQ(tbm_surface_internal_get_user_data(surface, key_ud, NULL), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetUserDataFailInvaildInput)
@@ -538,12 +617,13 @@ TEST_F(TBMSurfaceInternal, GetUserDataFailInvaildInput)
        int surf;
        int *data = NULL;
 
-       ASSERT_FALSE(tbm_surface_internal_get_user_data(surface,
-                       key_ud, (void **)&data)) << "invalid key" << std::endl;
-
-       ASSERT_FALSE(tbm_surface_internal_get_user_data((tbm_surface_h)&surf,
-                       key_ud, (void **)&data)) << "invalid surface" << std::endl;
+       EXPECT_EQ(tbm_surface_internal_get_user_data(surface,
+                       key_ud, (void **)&data), 0) << "invalid key" << std::endl;
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
+       EXPECT_EQ(tbm_surface_internal_get_user_data((tbm_surface_h)&surf,
+                       key_ud, (void **)&data), 0) << "invalid surface" << std::endl;
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, GetUserDataSuccess)
@@ -551,44 +631,56 @@ TEST_F(TBMSurfaceInternal, GetUserDataSuccess)
        unsigned long key_ud = 97456789;
        int *data = NULL;
 
-       ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        /* check set data */
-       ASSERT_TRUE(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data));
-       ASSERT_TRUE(data == &tbm_data_free_is_called);
+       EXPECT_EQ(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(data == &tbm_data_free_is_called, 1);
 
        /* check if data is NULL */
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, NULL));
-       ASSERT_TRUE(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data));
-       ASSERT_TRUE(data == NULL);
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, NULL), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_surface_internal_get_user_data(surface, key_ud, (void **)&data), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(data == NULL, 1);
 }
 
 /* tbm_surface_internal_delete_user_data(tbm_surface_h surface, unsigned long key) */
 TEST_F(TBMSurfaceInternal, DeleteUserDataFailNull)
 {
        static const int key_ud = 0;
-       ASSERT_FALSE(tbm_surface_internal_delete_user_data(NULL, key_ud));
+       EXPECT_EQ(tbm_surface_internal_delete_user_data(NULL, key_ud), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, DeleteUserDataFailInvaildInput)
 {
        static const int key_ud = 0;
        int surf;
-       ASSERT_FALSE(tbm_surface_internal_delete_user_data(surface, key_ud)) << "invalid key";
+       EXPECT_EQ(tbm_surface_internal_delete_user_data(surface, key_ud), 0) << "invalid key";
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 
-       ASSERT_FALSE(tbm_surface_internal_delete_user_data((tbm_surface_h)&surf, key_ud)) << "invalid surface";
+       EXPECT_EQ(tbm_surface_internal_delete_user_data((tbm_surface_h)&surf, key_ud), 0) << "invalid surface";
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
 
 TEST_F(TBMSurfaceInternal, DeleteUserDataSuccess)
 {
        unsigned long key_ud = UINT_MAX;
 
-       ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle));
-       ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
+       EXPECT_EQ(tbm_surface_internal_add_user_data(surface, key_ud, data_free_handle), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
 
        tbm_data_free_is_called = 0;
-       ASSERT_TRUE(tbm_surface_internal_delete_user_data(surface, key_ud));
-       ASSERT_TRUE(tbm_data_free_is_called);
-       ASSERT_FALSE(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called));
+       EXPECT_EQ(tbm_surface_internal_delete_user_data(surface, key_ud), 1);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+       EXPECT_EQ(tbm_data_free_is_called, 1);
+       EXPECT_EQ(tbm_surface_internal_set_user_data(surface, key_ud, &tbm_data_free_is_called), 0);
+       EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
 }
\ No newline at end of file