From: Roman Marchenko Date: Thu, 9 Nov 2017 14:44:47 +0000 (+0200) Subject: utest: add test for the API functions from tdm_surface_internal.h X-Git-Tag: accepted/tizen/unified/20171124.064515~9 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F49%2F159549%2F4;p=platform%2Fcore%2Fuifw%2Flibtbm.git utest: add test for the API functions from tdm_surface_internal.h Change-Id: I3ef4bb33238b1a8123831443ba69de8058e5a844 Signed-off-by: Roman Marchenko --- diff --git a/utests/Makefile.am b/utests/Makefile.am index 8e67f5f..6965fd8 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -4,7 +4,8 @@ tbm_utests_SOURCES = \ ut.cpp \ ut_main.cpp \ ut_tbm_bufmgr.cpp \ - ut_tbm_surface.cpp + ut_tbm_surface.cpp \ + ut_tbm_surface_internal.cpp tbm_utests_CXXFLAGS = \ ${CXXFLAGS} \ diff --git a/utests/ut.cpp b/utests/ut.cpp index 4effef1..9b769f5 100644 --- a/utests/ut.cpp +++ b/utests/ut.cpp @@ -62,13 +62,13 @@ void ut_set_default_tbm_env() setenv("TBM_DISPLAY_SERVER", "1", 1); } -int UtSurfaceInit::width = 720; -int UtSurfaceInit::height = 1024; -tbm_format UtSurfaceInit::format; -int UtSurfaceInit::num_formats; -tbm_format *UtSurfaceInit::formats; +int UtSurface::width = 720; +int UtSurface::height = 1024; +tbm_format UtSurface::format; +int UtSurface::num_formats; +tbm_format *UtSurface::formats; -void UtSurfaceInit::SetUpTestCase() +void UtSurface::SetUpTestCase() { tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -86,13 +86,20 @@ void UtSurfaceInit::SetUpTestCase() format = formats[0]; } -void UtSurfaceInit::SetUp() +void UtSurface::TearDownTestCase() +{ + if (formats) + free(formats); +} + + +void UtSurface::SetUp() { surface = tbm_surface_create(width, height, format); ASSERT_TRUE(surface != NULL); } -void UtSurfaceInit::TearDown() +void UtSurface::TearDown() { if (surface) tbm_surface_destroy(surface); diff --git a/utests/ut.h b/utests/ut.h index 07486e7..0d272e4 100644 --- a/utests/ut.h +++ b/utests/ut.h @@ -49,10 +49,11 @@ void ut_set_default_tbm_env(); /* test fixture class, which initializes bufmgr and allocate the tbm surface before the tests and * deinitializes bufmgr after tests which use the test fixture with this class */ -class UtSurfaceInit : public ::testing::Test +class UtSurface : public ::testing::Test { protected: static void SetUpTestCase(); + static void TearDownTestCase(); void SetUp(); void TearDown(); public: @@ -66,5 +67,7 @@ public: tbm_surface_h surface; }; +typedef UtSurface UtSurfaceInternal; + #endif // UT_H diff --git a/utests/ut_tbm_surface.cpp b/utests/ut_tbm_surface.cpp index 64366c7..f02ebca 100644 --- a/utests/ut_tbm_surface.cpp +++ b/utests/ut_tbm_surface.cpp @@ -34,7 +34,7 @@ TEST_F(UtInit, SurfaceQueryFormatSuccess) ASSERT_NE(NULL, formats); for (int i = 0; i < num; i++) ASSERT_NE(0, formats[i]); - + free(formats); } TEST_F(UtInit, SurfaceCeateFailInvalidGeometry) @@ -73,64 +73,64 @@ TEST_F(UtInit, SurfaceCeateSuccess) } } -TEST_F(UtSurfaceInit, SurfaceGetFormatFailInvalideInput) +TEST_F(UtSurface, SurfaceGetFormatFailInvalidInput) { tbm_surface_h invalide_surface = (tbm_surface_h)1; tbm_format fmt = tbm_surface_get_format(invalide_surface); ASSERT_EQ(0, fmt); } -TEST_F(UtSurfaceInit, SurfaceGetFormatFailNull) +TEST_F(UtSurface, SurfaceGetFormatFailNull) { tbm_format fmt = tbm_surface_get_format(NULL); ASSERT_EQ(0, fmt); } -TEST_F(UtSurfaceInit, SurfaceGetFormatSuccess) +TEST_F(UtSurface, SurfaceGetFormatSuccess) { tbm_format fmt = tbm_surface_get_format(surface); ASSERT_EQ(this->format, fmt); } -TEST_F(UtSurfaceInit, SurfaceGetWidthFailInvalideInput) +TEST_F(UtSurface, SurfaceGetWidthFailInvalidInput) { tbm_surface_h invalide_surface = (tbm_surface_h)1; int width = tbm_surface_get_width(invalide_surface); ASSERT_EQ(0, width); } -TEST_F(UtSurfaceInit, SurfaceGetWidthFailNull) +TEST_F(UtSurface, SurfaceGetWidthFailNull) { int width = tbm_surface_get_width(NULL); ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, width); } -TEST_F(UtSurfaceInit, SurfaceGetWidthSuccess) +TEST_F(UtSurface, SurfaceGetWidthSuccess) { int width = tbm_surface_get_width(surface); ASSERT_EQ(this->width, width); } -TEST_F(UtSurfaceInit, SurfaceGetHeightFailInvalideInput) +TEST_F(UtSurface, SurfaceGetHeightFailInvalidInput) { tbm_surface_h invalide_surface = (tbm_surface_h)1; int height = tbm_surface_get_height(invalide_surface); ASSERT_EQ(0, height); } -TEST_F(UtSurfaceInit, SurfaceGetHeightFailNull) +TEST_F(UtSurface, SurfaceGetHeightFailNull) { int height = tbm_surface_get_height(NULL); ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, height); } -TEST_F(UtSurfaceInit, SurfaceGetHeightSuccess) +TEST_F(UtSurface, SurfaceGetHeightSuccess) { int height = tbm_surface_get_height(surface); ASSERT_EQ(this->height, height); } -TEST_F(UtSurfaceInit, SurfaceGetInfoInvalideInput) +TEST_F(UtSurface, SurfaceGetInfoInvalidInput) { tbm_surface_h invalide_surface = (tbm_surface_h)1; tbm_surface_info_s info; @@ -140,7 +140,7 @@ TEST_F(UtSurfaceInit, SurfaceGetInfoInvalideInput) ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_OPERATION, result); } -TEST_F(UtSurfaceInit, SurfaceGetInfoFailNull) +TEST_F(UtSurface, SurfaceGetInfoFailNull) { tbm_surface_info_s info; tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -155,7 +155,7 @@ TEST_F(UtSurfaceInit, SurfaceGetInfoFailNull) ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result); } -TEST_F(UtSurfaceInit, SurfaceGetInfoSuccess) +TEST_F(UtSurface, SurfaceGetInfoSuccess) { tbm_surface_info_s info; tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -170,7 +170,7 @@ TEST_F(UtSurfaceInit, SurfaceGetInfoSuccess) ASSERT_GT(info.size, 0); } -TEST_F(UtSurfaceInit, SurfaceMapFailInvalideInput) +TEST_F(UtSurface, SurfaceMapFailInvalidInput) { tbm_surface_info_s info; tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -180,7 +180,7 @@ TEST_F(UtSurfaceInit, SurfaceMapFailInvalideInput) ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_OPERATION, result); } -TEST_F(UtSurfaceInit, SurfaceMapFailNull) +TEST_F(UtSurface, SurfaceMapFailNull) { tbm_surface_info_s info; tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -192,7 +192,7 @@ TEST_F(UtSurfaceInit, SurfaceMapFailNull) ASSERT_EQ(TBM_SURFACE_ERROR_INVALID_PARAMETER, result); } -TEST_F(UtSurfaceInit, SurfaceMapSuccess) +TEST_F(UtSurface, SurfaceMapSuccess) { tbm_surface_info_s info; tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; @@ -210,7 +210,7 @@ TEST_F(UtSurfaceInit, SurfaceMapSuccess) ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result); } -TEST_F(UtSurfaceInit, SurfaceUnmapFailInvalideInput) +TEST_F(UtSurface, SurfaceUnmapFailInvalidInput) { tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; tbm_surface_h invalide_surface = (tbm_surface_h)1; @@ -218,7 +218,7 @@ TEST_F(UtSurfaceInit, SurfaceUnmapFailInvalideInput) ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result); } -TEST_F(UtSurfaceInit, SurfaceUnmapFailNull) +TEST_F(UtSurface, SurfaceUnmapFailNull) { tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; diff --git a/utests/ut_tbm_surface_internal.cpp b/utests/ut_tbm_surface_internal.cpp new file mode 100644 index 0000000..a69b2d8 --- /dev/null +++ b/utests/ut_tbm_surface_internal.cpp @@ -0,0 +1,580 @@ +#include +#include + +#include +#include +#include +#include "ut.h" + +/* int tbm_surface_internal_query_supported_formats(uint32_t **formats, uint32_t *num) */ +TEST_F(UtInit, SurfaceInternalQueryFormatsFailNull) +{ + int num = 0; + tbm_format *formats = NULL; + + ut_set_default_tbm_env(); + + ASSERT_FALSE(tbm_surface_internal_query_supported_formats(&formats, NULL)); + + ASSERT_FALSE(tbm_surface_internal_query_supported_formats(NULL, &num)); +} + +TEST_F(UtInit, SurfaceInternalQueryFormatsSuccess) +{ + int num = 0; + tbm_format *formats = NULL; + + ut_set_default_tbm_env(); + + ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num)); + ASSERT_NE(0, num); + ASSERT_NE(NULL, formats); + for (int i = 0; i < num; i++) + ASSERT_NE(0, formats[i]); + + if (formats) + free(formats); +} + + +/* tbm_surface_h tbm_surface_internal_create_with_flags(int width, int height, int format, int flags) */ +TEST_F(UtInit, SurfaceInternalCeatewithFlagsFailInvalidInput) +{ + tbm_surface_h surface = NULL; + + ut_set_default_tbm_env(); + + surface = tbm_surface_internal_create_with_flags(-1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT); + ASSERT_EQ(NULL, surface); // Expected Value: NULL + + surface = tbm_surface_internal_create_with_flags(720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT); + ASSERT_EQ(NULL, surface); + + surface = tbm_surface_internal_create_with_flags(720, 1024, 0, TBM_BO_DEFAULT); + ASSERT_EQ(NULL, surface); + + surface = tbm_surface_internal_create_with_flags(720, 1024, 0, (TBM_BO_WC << 1)); + ASSERT_EQ(NULL, surface); +} + +TEST_F(UtInit, SurfaceInternalCeatewithFlagsSuccess) +{ + tbm_surface_h surface = NULL; + int num = 0; + tbm_format *formats = NULL; + + ut_set_default_tbm_env(); + + ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num)); + + for (int i = 0; i < num; i++) { + surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT); + ASSERT_NE(NULL, surface); + tbm_surface_internal_destroy(surface); + } + + if (formats) + free(formats); +} + + +/* void tbm_surface_internal_destroy(tbm_surface_h surface) */ +TEST_F(UtInit, SurfaceInternalSurfaceInteranlDestroyFailNULL) +{ + ut_set_default_tbm_env(); + + tbm_surface_internal_destroy(NULL); +} + +TEST_F(UtInit, SurfaceInteranlDestroyFailTwice) +{ + tbm_surface_h surface = NULL; + int num = 0; + tbm_format *formats = NULL; + + ASSERT_TRUE(tbm_surface_internal_query_supported_formats(&formats, &num)); + surface = tbm_surface_internal_create_with_flags(720, 1024, formats[0], TBM_BO_DEFAULT); + + tbm_surface_internal_destroy(surface); + + tbm_surface_internal_destroy(surface); + + if(formats) + free(formats); +} + + +/* tbm_surface_internal_is_valid(tbm_surface_h surface) */ +TEST_F(UtSurfaceInternal, IsValid) +{ + int invalid_surf; + + ASSERT_FALSE(tbm_surface_internal_is_valid(NULL)); + ASSERT_FALSE(tbm_surface_internal_is_valid((tbm_surface_h)&invalid_surf)); + ASSERT_TRUE(tbm_surface_internal_is_valid(surface));; +} + + +/* int tbm_surface_internal_get_num_bos(tbm_surface_h surface) */ +TEST_F(UtSurfaceInternal, GetNumBosFailNULL) +{ + int num = tbm_surface_internal_get_num_bos(NULL); + ASSERT_EQ(0, num); +} + +TEST_F(UtSurfaceInternal, GetNumBosSuccess) +{ + int num = tbm_surface_internal_get_num_bos(surface); + ASSERT_TRUE(num > 0); +} + +/* tbm_bo tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx) */ +TEST_F(UtSurfaceInternal, GetBoFailNULL) +{ + tbm_bo bo = tbm_surface_internal_get_bo(NULL, 0); + ASSERT_EQ(NULL, bo); +} + +TEST_F(UtSurfaceInternal, 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(NULL, bo); + + num = tbm_surface_internal_get_num_bos(surface); + ASSERT_TRUE(num > 0); + + /* invalid index of bo */ + bo = tbm_surface_internal_get_bo(surface, -1); + ASSERT_EQ(NULL, bo); + bo = tbm_surface_internal_get_bo(surface, num); + ASSERT_EQ(NULL, bo); +} + +TEST_F(UtSurfaceInternal, GetBoSuccess) +{ + tbm_bo bo = NULL; + int num = 0; + + num = tbm_surface_internal_get_num_bos(surface); + ASSERT_TRUE(num > 0); + + for (int i = 0; i < num; i++) { + bo = tbm_surface_internal_get_bo(surface, i); + ASSERT_NE(NULL, bo); + } +} + +/* tbm_surface_h tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, tbm_bo *bos, int num) */ +TEST_F(UtSurfaceInternal, CreateWithBosNullInput) +{ + tbm_surface_h surf = NULL; + tbm_surface_info_s info = { 0 }; + tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; + tbm_bo bos[1]; + + result = tbm_surface_get_info(surface, &info); + ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result); + + surf = tbm_surface_internal_create_with_bos(NULL, NULL, 1); + + surf = tbm_surface_internal_create_with_bos(&info, NULL, 1); + ASSERT_EQ(NULL, surf); + + surf = tbm_surface_internal_create_with_bos(NULL, bos, 1); + ASSERT_EQ(NULL, surf); +} + +TEST_F(UtSurfaceInternal, CreateWithBosFailInvalidInput) +{ + tbm_surface_h surf = NULL; + tbm_surface_info_s info; + tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; + tbm_bo bos[4] = { NULL }; + int num; + + result = tbm_surface_get_info(surface, &info); + ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result); + + num = tbm_surface_internal_get_num_bos(surface); + ASSERT_TRUE(num > 0); + + for (int i = 0; i < num; i++) { + bos[i] = tbm_surface_internal_get_bo(surface, i); + ASSERT_NE(NULL, bos[i]); + } + + + /* wrong number of bo */ + surf = tbm_surface_internal_create_with_bos(&info, bos, num + 1); + ASSERT_EQ(NULL, surf); + surf = tbm_surface_internal_create_with_bos(&info, bos, num - 1); + ASSERT_EQ(NULL, surf); + + /* invalid bo */ + bos[num-1] = NULL; + surf = tbm_surface_internal_create_with_bos(&info, bos, num); + ASSERT_EQ(NULL, surf); +} + +TEST_F(UtSurfaceInternal, CreateWithBosSuccess) +{ + tbm_surface_h surf = NULL; + tbm_surface_info_s info; + tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE; + tbm_bo bos[4] = { NULL }; + int num = 0; + + result = tbm_surface_get_info(surface, &info); + ASSERT_EQ(TBM_SURFACE_ERROR_NONE, result); + + num = tbm_surface_internal_get_num_bos(surface); + ASSERT_TRUE(num > 0); + + for (int i = 0; i < num; i++) { + bos[i] = tbm_surface_internal_get_bo(surface, i); + ASSERT_NE(NULL, bos[i]); + } + + surf = tbm_surface_internal_create_with_bos(&info, bos, num); + ASSERT_NE(NULL, surf); + tbm_surface_internal_destroy(surf); + + /* set size plane to zero*/ + info.planes[0].size = 0; + surf = tbm_surface_internal_create_with_bos(&info, bos, num); + ASSERT_NE(NULL, surf); + tbm_surface_internal_destroy(surf); + + /* set bpp to zero*/ + info.bpp = 0; + surf = tbm_surface_internal_create_with_bos(&info, bos, num); + ASSERT_NE(NULL, surf); + tbm_surface_internal_destroy(surf); + + /* set size to zero*/ + info.size = 0; + surf = tbm_surface_internal_create_with_bos(&info, bos, num); + ASSERT_NE(NULL, surf); + tbm_surface_internal_destroy(surf); +} + +/* void tbm_surface_internal_unref(tbm_surface_h surface) */ +TEST_F(UtSurfaceInternal, UnrefFailNull) +{ + tbm_surface_internal_unref(NULL); +} + +TEST_F(UtSurfaceInternal, UnrefFailInvaildInput) +{ + int surf; + tbm_surface_internal_unref((tbm_surface_h)&surf); +} + +TEST_F(UtSurfaceInternal, UnrefSuccess) +{ + tbm_surface_internal_unref(surface); + + ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) ; + + surface = NULL; +} + +/* void tbm_surface_internal_ref(tbm_surface_h surface) */ +TEST_F(UtInit, RefFailNull) +{ + tbm_surface_internal_ref(NULL); +} + +TEST_F(UtInit, RefFailInvaildInput) +{ + int surf; + tbm_surface_internal_ref((tbm_surface_h)&surf); +} + +TEST_F(UtSurfaceInternal, RefSuccess) +{ + tbm_surface_internal_ref(surface); + tbm_surface_internal_unref(surface); + ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) ; +} + +/* tbm_surface_internal_get_num_planes() */ +TEST_F(UtInit, GetNumPlanes) +{ + int num = 0; + num = tbm_surface_internal_get_num_planes(0); + ASSERT_EQ(0, num); + + num = tbm_surface_internal_get_num_planes(TBM_FORMAT_ARGB8888); + ASSERT_EQ(1, num); + + num = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12); + ASSERT_EQ(2, num); + + num = tbm_surface_internal_get_num_planes(TBM_FORMAT_YUV410); + ASSERT_EQ(3, num); +} + +/* tbm_surface_internal_get_size() */ +TEST_F(UtSurfaceInternal, GetSizeFailNull) +{ + int size = tbm_surface_internal_get_size(NULL); + ASSERT_EQ(0, size); +} + +TEST_F(UtSurfaceInternal, GetSizeFailInvaildInput) +{ + int surf; + int size = tbm_surface_internal_get_size((tbm_surface_h)&surf); + ASSERT_EQ(0, size); +} + +TEST_F(UtSurfaceInternal, GetSizeSuccess) +{ + int size = tbm_surface_internal_get_size(surface); + ASSERT_GT(size, 0); +} + +/* tbm_surface_internal_get_plane_data(tbm_surface_h surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch) */ +TEST_F(UtSurfaceInternal, GetPlaneDataFailNull) +{ + ASSERT_FALSE(tbm_surface_internal_get_plane_data(NULL, 0, NULL, NULL, NULL)); +} + +TEST_F(UtSurfaceInternal, 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, 4, NULL, NULL, NULL)); +} + +TEST_F(UtSurfaceInternal, 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); + + ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, &offset, NULL)); + + ASSERT_TRUE(tbm_surface_internal_get_plane_data(surface, 0, NULL, NULL, &pitch)); + ASSERT_GT(pitch, 0); +} + +/* tbm_surface_internal_get_bpp(tbm_format format) */ +TEST_F(UtInit, GetBpp) +{ + int bpp = 0; + bpp = tbm_surface_internal_get_bpp(0); + ASSERT_EQ(0, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB332); + ASSERT_EQ(8, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB565); + ASSERT_EQ(16, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_RGB888); + ASSERT_EQ(24, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_ARGB8888); + ASSERT_EQ(32, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12); + ASSERT_EQ(12, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV16); + ASSERT_EQ(16, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV410); + ASSERT_EQ(9, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV411); + ASSERT_EQ(12, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV422); + ASSERT_EQ(16, bpp); + + bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YUV444); + ASSERT_EQ(24, bpp); +} +/* tbm_surface_internal_get_plane_bo_idx(tbm_surface_h surface, int plane_idx) */ +TEST_F(UtSurfaceInternal, GetPlaneBoIndexFailNull) +{ + int idx = tbm_surface_internal_get_plane_bo_idx(NULL, 0); + ASSERT_EQ(0, idx); +} + +TEST_F(UtSurfaceInternal, GetPlaneBoIndexFailInvaildInput) +{ + int surf; + int idx; + + idx = tbm_surface_internal_get_plane_bo_idx((tbm_surface_h)&surf, 0); + ASSERT_EQ(0, idx); + + idx = tbm_surface_internal_get_plane_bo_idx(surface, -1); + ASSERT_EQ(0, idx); +} + +TEST_F(UtSurfaceInternal, GetPlaneBoIndexSuccess) +{ + int idx; + + idx = tbm_surface_internal_get_plane_bo_idx(surface, 0); + ASSERT_EQ(0, idx); +} + +static int tbm_data_free_is_called = 0; +void data_free_handle(void *user_data) +{ + ASSERT_TRUE(user_data == &tbm_data_free_is_called); + int * is_called = user_data; + *((int *)user_data) = 1; +} + +/* tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key, tbm_data_free data_free_func) */ +TEST_F(UtSurfaceInternal, AddUserDataFailNull) +{ + static const int key_ud; + ASSERT_FALSE(tbm_surface_internal_add_user_data(NULL, &key_ud, NULL)); +} + +TEST_F(UtSurfaceInternal, AddUserDataFailInvaildInput) +{ + static const int key_ud; + int surf; + ASSERT_FALSE(tbm_surface_internal_add_user_data((tbm_surface_h)&surf, &key_ud, NULL)); +} + +TEST_F(UtSurfaceInternal, AddUserDataSuccess) +{ + int key_ud; + ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, &key_ud, NULL)); +} + +TEST_F(UtSurfaceInternal, AddUserDataFailDoubleKey) +{ + int key_ud; + ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, &key_ud, NULL)); + + ASSERT_FALSE(tbm_surface_internal_add_user_data(surface, &key_ud, NULL)); +} + +/* tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key, void *data) */ +TEST_F(UtSurfaceInternal, SetUserDataFailNull) +{ + static const int key_ud; + ASSERT_FALSE(tbm_surface_internal_set_user_data(NULL, &key_ud, &tbm_data_free_is_called)); +} + +TEST_F(UtSurfaceInternal, SetUserDataFailInvaildInput) +{ + static const int key_ud; + 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"; + +} + +TEST_F(UtSurfaceInternal, SetUserDataSuccess) +{ + int key_ud; + ASSERT_TRUE(tbm_surface_internal_add_user_data(surface, &key_ud, data_free_handle)); + + /*the first call*/ + ASSERT_TRUE(tbm_surface_internal_set_user_data(surface, &key_ud, &tbm_data_free_is_called)); + + /*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); + + /*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); +} + +/* tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key, void **data) */ +TEST_F(UtSurfaceInternal, GetUserDataFailNull) +{ + static const int key_ud; + int * data = NULL; + ASSERT_FALSE(tbm_surface_internal_get_user_data(NULL, &key_ud, &data)); + + ASSERT_FALSE(tbm_surface_internal_get_user_data(surface, &key_ud, NULL)); +} + +TEST_F(UtSurfaceInternal, GetUserDataFailInvaildInput) +{ + static const int key_ud; + int surf; + int * data = NULL; + + ASSERT_FALSE(tbm_surface_internal_get_user_data(surface, + &key_ud, &data)) << "invalid key"; + + ASSERT_FALSE(tbm_surface_internal_get_user_data((tbm_surface_h)&surf, + &key_ud, &data)) << "invalid surface"; + +} + +TEST_F(UtSurfaceInternal, GetUserDataSuccess) +{ + int key_ud; + 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)); + + /* check set data */ + ASSERT_TRUE(tbm_surface_internal_get_user_data(surface, &key_ud, &data)); + ASSERT_TRUE(data == &tbm_data_free_is_called); + + /* 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, &data)); + ASSERT_TRUE(data == NULL); +} + +/* tbm_surface_internal_delete_user_data(tbm_surface_h surface, unsigned long key) */ +TEST_F(UtSurfaceInternal, DeleteUserDataFailNull) +{ + static const int key_ud; + ASSERT_FALSE(tbm_surface_internal_delete_user_data(NULL, &key_ud)); +} + +TEST_F(UtSurfaceInternal, DeleteUserDataFailInvaildInput) +{ + static const int key_ud; + int surf; + ASSERT_FALSE(tbm_surface_internal_delete_user_data(surface, &key_ud)) << "invalid key"; + + ASSERT_FALSE(tbm_surface_internal_delete_user_data((tbm_surface_h)&surf, &key_ud)) << "invalid surface"; + +} + +TEST_F(UtSurfaceInternal, DeleteUserDataSuccess) +{ + int key_ud; + + 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)); + + 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)); +}