change all symbol and file name.
Change-Id: Ia4cfcbbcb41ead714f8fa7a0a00d42a54a1cb528
-if HAVE_UTEST
-SUBDIRS = src utests
+if HAVE_HALTESTS
+SUBDIRS = src haltests
else
SUBDIRS = src
endif
[ BUFMGR_MODULE_PATH="$withval" ],
[ BUFMGR_MODULE_PATH="${DEFAULT_BUFMGR_MODULE_PATH}" ])
-AC_ARG_WITH(utests, AS_HELP_STRING([--with-utests=yes/no], [whether build/run unit tests or not]),
- [ utests="$withval" ],
- [ utests="no" ])
+AC_ARG_WITH(haltests, AS_HELP_STRING([--with-haltests=yes/no], [whether build/run unit tests or not]),
+ [ haltests="$withval" ],
+ [ haltests="no" ])
-AM_CONDITIONAL(HAVE_UTEST, test "x$utests" = "xyes")
+AM_CONDITIONAL(HAVE_HALTESTS, test "x$haltests" = "xyes")
#AC_DEFINE(BUFMGR_MODULE_DIR, "${BUFMGR_MODULE_PATH}", [Directory for the modules of tbm_bufmgr])
AC_DEFINE_UNQUOTED(BUFMGR_MODULE_DIR, "${BUFMGR_MODULE_PATH}", [Directory for the modules of tbm_bufmgr])
src/Makefile
Makefile
libtbm.pc
- utests/Makefile])
+ haltests/Makefile])
echo ""
echo "CFLAGS : $CFLAGS"
--- /dev/null
+bin_PROGRAMS = tbm-haltests
+
+tbm_haltests_SOURCES = \
+ tc_main.cpp \
+ tc_tbm_env.cpp \
+ tc_tbm_bufmgr.cpp \
+ tc_tbm_bo.cpp \
+ tc_tbm_surface.cpp \
+ tc_tbm_surface_internal.cpp \
+ tc_tbm_surface_queue.cpp \
+ tc_tbm_backend.cpp \
+ tc_tbm_log.cpp
+
+tbm_haltests_CXXFLAGS = \
+ @DLOG_CFLAGS@ \
+ ${CXXFLAGS} \
+ -I$(top_builddir)/src \
+ -I$(includedir)/gtest
+
+tbm_haltests_LDFLAGS = \
+ @DLOG_LIBS@ \
+ ${LDFLAGS} \
+ $(top_builddir)/src/libtbm.la \
+ -lgtest \
+ -pthread
+
+check:
+ ./tbm-haltests
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "gtest/gtest.h"
+
+#ifdef TIZEN_TEST_GCOV
+extern "C" void __gcov_flush(void);
+#endif
+
+int main(int argc, char **argv)
+{
+ auto AllTestSuccess = false;
+
+#ifdef TIZEN_TEST_GCOV
+ setenv("GCOV_PREFIX", "/tmp", 1);
+#endif
+
+ try {
+ ::testing::InitGoogleTest(&argc, argv);
+ ::testing::FLAGS_gtest_death_test_style = "fast";
+ } catch ( ... ) {
+ std::cout << "error while trying to init google tests.\n";
+ exit(EXIT_FAILURE);
+ }
+
+ try {
+ AllTestSuccess = RUN_ALL_TESTS() == 0 ? true : false;
+ } catch (const ::testing::internal::GoogleTestFailureException & e) {
+ AllTestSuccess = false;
+ std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;
+ std::cout << "\n";
+ }
+
+#ifdef TIZEN_TEST_GCOV
+ __gcov_flush();
+#endif
+
+ return AllTestSuccess;
+}
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#ifndef UT_H
+#define UT_H
+
+#include <vector>
+#include <list>
+#include <climits>
+#include <pthread.h>
+#include <gtest/gtest.h>
+#include <stdlib.h>
+#include <tbm_bufmgr_int.h>
+#include <wayland-server-protocol.h>
+
+#define TBM_UT_ENTRY() \
+ TBM_INFO("--------------------------------------------- %s", typeid(*this).name())
+
+#define TBM_UT_CHECK_FLAG(FLAG) \
+ do {\
+ if(!(FLAG)) \
+ TBM_INFO("[ ] not supported");\
+ } while(0)
+
+#define TBM_UT_SKIP_FLAG(FLAG) \
+ do {\
+ if(!(FLAG)) {\
+ TBM_INFO("[ SKIPPED ] not supported");\
+ return;\
+ }\
+ } while(0)
+
+#define TBM_UT_NEVER_GET_HERE() \
+ do {\
+ TBM_INFO("!!! TBM UT NEVER GET HERE !!!");\
+ } while(0)
+#define TBM_UT_RETURN_IF_FAIL(cond) { \
+ if (!(cond)) { \
+ TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
+ return; \
+ } \
+}
+#define TBM_UT_RETURN_FALSE_IF_FAIL(cond) { \
+ if (!(cond)) { \
+ TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
+ return false; \
+ } \
+}
+#define TBM_UT_GOTO_IF_FAIL(cond, dst) { \
+ if (!(cond)) { \
+ TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
+ goto dst; \
+ } \
+}
+
+#define TBM_UT_DUMP_DIR "/tmp/tbm_dump"
+#define UT_TBM_INVALID_VALUE -42
+#define TBM_UT_INVALID_UINT_VALUE 99999
+#define UT_TBM_BO_SIZE 1024
+#define UT_TBM_SURFACE_QUEUE_SIZE 4
+
+using ::testing::TestWithParam;
+using ::testing::Bool;
+using ::testing::Values;
+using ::testing::Combine;
+
+class TBMEnv : public TestWithParam< ::testing::tuple<bool, bool, const char*> >
+{
+public:
+ void SetUp(void);
+ void TearDown(void);
+};
+
+class TBMBufmgr : public TBMEnv
+{
+public:
+ TBMBufmgr();
+ void SetUp(void);
+ void TearDown(void);
+
+ tbm_bufmgr bufmgr;
+};
+
+#endif // UT_H
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: SooChan Lim <sc1.lim@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+#define UT_TBM_ITER_COUNT 100
+
+class TBMBackend : public TBMEnv
+{
+public:
+ void SetUp(void);
+ void TearDown(void);
+};
+
+void TBMBackend::SetUp()
+{
+ TBMEnv::SetUp();
+}
+
+void TBMBackend::TearDown()
+{
+ TBMEnv::TearDown();
+}
+
+// bufmgr init, deinit
+TEST_F(TBMBackend, BufmgrInitDeinit)
+{
+ tbm_bufmgr bufmgr;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ tbm_bufmgr_deinit(bufmgr);
+}
+
+// backend symbol check
+TEST_F(TBMBackend, BufmgrCheckSymbols)
+{
+ tbm_bufmgr bufmgr;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ // check backend symbols
+ if (bufmgr->backend_module_data) {
+ EXPECT_TRUE(bufmgr->backend_module_data->init);
+ EXPECT_TRUE(bufmgr->backend_module_data->deinit);
+
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_capabilities);
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_bind_native_display);
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_supported_formats);
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_plane_data);
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_alloc_bo);
+ if (!bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format)
+ printf("No bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format symbole.\n");
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_fd);
+ EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_key);
+
+ EXPECT_TRUE(bufmgr->bo_func->bo_free);
+ EXPECT_TRUE(bufmgr->bo_func->bo_get_size);
+ EXPECT_TRUE(bufmgr->bo_func->bo_get_memory_types);
+ EXPECT_TRUE(bufmgr->bo_func->bo_get_handle);
+ EXPECT_TRUE(bufmgr->bo_func->bo_map);
+ EXPECT_TRUE(bufmgr->bo_func->bo_unmap);
+ if (!bufmgr->bo_func->bo_lock)
+ printf("No bufmgr->bo_func->bo_lock symbole.\n");
+ if (!bufmgr->bo_func->bo_unlock)
+ printf("No bufmgr->bo_func->bo_unlock symbole.\n");
+ EXPECT_TRUE(bufmgr->bo_func->bo_export_fd);
+ EXPECT_TRUE(bufmgr->bo_func->bo_export_key);
+ } else {
+ EXPECT_TRUE(bufmgr->backend->priv);
+ EXPECT_TRUE(bufmgr->backend->bufmgr_deinit);
+ EXPECT_TRUE(bufmgr->backend->bufmgr_bind_native_display);
+ EXPECT_TRUE(bufmgr->backend->bo_alloc);
+ EXPECT_TRUE(bufmgr->backend->bo_free);
+ EXPECT_TRUE(bufmgr->backend->bo_size);
+ EXPECT_TRUE(bufmgr->backend->bo_get_flags);
+ EXPECT_TRUE(bufmgr->backend->bo_get_handle);
+ EXPECT_TRUE(bufmgr->backend->bo_map && bufmgr->backend->bo_unmap);
+ if (!bufmgr->backend->bo_lock)
+ printf("No bufmgr->backend->bo_lock symbole.\n");
+ if (!bufmgr->backend->bo_unlock)
+ printf("No bufmgr->backend->bo_unlock symbole.\n");
+ EXPECT_TRUE(bufmgr->backend->bo_import_fd && bufmgr->backend->bo_export_fd);
+ EXPECT_TRUE(bufmgr->backend->bo_import && bufmgr->backend->bo_export);
+ EXPECT_TRUE(bufmgr->backend->surface_supported_format);
+ if (!bufmgr->backend->surface_bo_alloc)
+ printf("No bufmgr->backend->surface_bo_alloc symbole.\n");
+ EXPECT_TRUE(bufmgr->backend->surface_get_plane_data);
+ }
+
+ tbm_bufmgr_deinit(bufmgr);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// bo_alloc, bo_free, bo_size test
+TEST_F(TBMBackend, BufmgrBindNativeDisplay)
+{
+ tbm_bufmgr bufmgr;
+ struct wl_display *native_display = NULL;
+ int ret;
+
+ native_display = wl_display_create();
+ assert(native_display != NULL);
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ ret = wl_display_add_socket(native_display, "ut-tbm-socket");
+ EXPECT_TRUE(ret == 0);
+
+ ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
+ EXPECT_TRUE(ret == 1);
+
+ tbm_bufmgr_deinit(bufmgr);
+
+ wl_display_destroy(native_display);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// bo_alloc, bo_free, bo_size test
+TEST_F(TBMBackend, BoAllocFree)
+{
+ tbm_bufmgr bufmgr;
+ tbm_bo bo[UT_TBM_ITER_COUNT];
+ int i, alloc_size, ret_size;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ // bufmgr->backend->bo_alloc
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
+ alloc_size = 10 * i + 1;
+ bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
+ EXPECT_TRUE(bo[i] != NULL);
+
+ // bufmgr->backend->bo_size
+ ret_size = tbm_bo_size(bo[i]);
+ if (alloc_size != ret_size)
+ printf("The alloc_size is different from return value of the tbm_bo_size().");
+ }
+
+ // bufmgr->backend->bo_free
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++)
+ tbm_bo_unref(bo[i]);
+
+ tbm_bufmgr_deinit(bufmgr);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
+TEST_F(TBMBackend, BoGetHandleMapUnmap)
+{
+ tbm_bufmgr bufmgr;
+ tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
+ tbm_bo bo[UT_TBM_ITER_COUNT];
+ int i, j, alloc_size, ret_size;
+ int ret = 0;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ // bufmgr->backend->bo_alloc
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
+ alloc_size = 10 * i + 1;
+ bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
+ EXPECT_TRUE(bo[i] != NULL);
+
+ // bufmgr->backend->bo_size
+ ret_size = tbm_bo_size(bo[i]);
+ if (alloc_size != ret_size)
+ printf("The alloc_size is different from return value of the tbm_bo_size().");
+
+ for (j = TBM_DEVICE_DEFAULT; j <= TBM_DEVICE_3D; j++) {
+ bo_handle[i] = tbm_bo_get_handle(bo[i], j);
+ EXPECT_TRUE(bo_handle[i].ptr != NULL);
+ bo_handle[i] = tbm_bo_map(bo[i], j, TBM_OPTION_READ|TBM_OPTION_WRITE);
+ EXPECT_TRUE(bo_handle[i].ptr != NULL);
+ ret = tbm_bo_unmap(bo[i]);
+ EXPECT_TRUE(ret == 1);
+ }
+ }
+
+ // bufmgr->backend->bo_free
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++)
+ tbm_bo_unref(bo[i]);
+
+ tbm_bufmgr_deinit(bufmgr);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// bo_export_fd, bo_import_fd
+TEST_F(TBMBackend, BoExportImportFd)
+{
+ tbm_bufmgr bufmgr;
+ tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
+ tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
+ tbm_bo bo[UT_TBM_ITER_COUNT];
+ tbm_bo import_bo[UT_TBM_ITER_COUNT];
+ tbm_fd fd[UT_TBM_ITER_COUNT];
+ int i, alloc_size;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ // bufmgr->backend->bo_alloc
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
+ alloc_size = 10 * i + 1;
+ bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
+ EXPECT_TRUE(bo[i] != NULL);
+
+ bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
+ EXPECT_TRUE(bo_handle[i].ptr != NULL);
+
+ fd[i] = tbm_bo_export_fd(bo[i]);
+ EXPECT_TRUE(fd[i] >= 0);
+
+ import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
+ EXPECT_TRUE(import_bo[i] != NULL);
+
+ import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
+ EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
+ }
+
+ // bufmgr->backend->bo_free
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++)
+ tbm_bo_unref(bo[i]);
+
+ tbm_bufmgr_deinit(bufmgr);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// bo_export, bo_import
+TEST_F(TBMBackend, BoExportImport)
+{
+ tbm_bufmgr bufmgr;
+ tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
+ tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
+ tbm_bo bo[UT_TBM_ITER_COUNT];
+ tbm_bo import_bo[UT_TBM_ITER_COUNT];
+ tbm_key key[UT_TBM_ITER_COUNT];
+ int i, alloc_size;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+
+ // bufmgr->backend->bo_alloc
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
+ alloc_size = 10 * i + 1;
+ bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
+ EXPECT_TRUE(bo[i] != NULL);
+
+ bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
+ EXPECT_TRUE(bo_handle[i].ptr != NULL);
+
+ key[i] = tbm_bo_export(bo[i]);
+ EXPECT_TRUE(key[i] != 0);
+
+ import_bo[i] = tbm_bo_import(bufmgr, key[i]);
+ EXPECT_TRUE(import_bo[i] != NULL);
+
+ import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
+ EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
+ }
+
+ // bufmgr->backend->bo_free
+ for (i = 0; i < UT_TBM_ITER_COUNT; i++)
+ tbm_bo_unref(bo[i]);
+
+ tbm_bufmgr_deinit(bufmgr);
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// surface_supported_format
+TEST_F(TBMBackend, SurfaceSupportedFormat)
+{
+ uint32_t num_formats = 0;
+ tbm_format *formats = NULL;
+ int format = -1;
+ int ret = 0;
+
+ ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
+ EXPECT_TRUE(ret == 1);
+ EXPECT_TRUE(formats != NULL);
+
+ for (uint32_t i = 0; i < num_formats; i++)
+ if (formats[i] == TBM_FORMAT_ARGB8888)
+ format = TBM_FORMAT_ARGB8888;
+
+ /* fail if there is no TBM_FORMAT_ARGB8888 format */
+ EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
+
+ free(formats);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+// surface_bo_alloc, surface_get_plane_data
+TEST_F(TBMBackend, SurfaceBoAlloc)
+{
+ uint32_t num_formats = 0;
+ tbm_format *formats = NULL;
+ int ret = 0;
+ tbm_surface_h surface;
+
+ ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
+ EXPECT_TRUE(ret == 1);
+ EXPECT_TRUE(formats != NULL);
+
+ for (uint32_t i = 0; i < num_formats; i++) {
+ surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
+ EXPECT_TRUE(surface != NULL);
+ tbm_surface_internal_destroy(surface);
+ }
+
+ free(formats);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+
+
--- /dev/null
+
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+class TBMBo : public TBMBufmgr
+{
+public:
+ TBMBo();
+ void SetUp(void);
+ void TearDown(void);
+
+ unsigned int bufmgr_capability;
+};
+
+TBMBo::TBMBo()
+{
+ bufmgr_capability = TBM_BUFMGR_CAPABILITY_NONE;
+}
+
+void TBMBo::SetUp()
+{
+ TBMBufmgr::SetUp();
+
+ bufmgr_capability = tbm_bufmgr_get_capability(bufmgr);
+ EXPECT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
+}
+
+void TBMBo::TearDown()
+{
+ TBMBufmgr::TearDown();
+}
+
+/* tbm_bo_alloc() */
+
+TEST_F(TBMBo, BoAllocUnref)
+{
+ tbm_bo bo;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bo_unref(bo);
+}
+
+TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
+{
+ tbm_bo bo;
+ tbm_bufmgr invalid_bufmgr;
+
+ invalid_bufmgr = NULL;
+ bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
+ bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoAllocWithSizeParamTest)
+{
+ tbm_bo bo;
+
+ bo = tbm_bo_alloc(bufmgr, -1, TBM_BO_DEFAULT);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoAllocWithFlagsParamTest)
+{
+ tbm_bo bo;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ tbm_bo_unref(bo);
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_SCANOUT);
+ 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);
+ 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);
+ 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_ref() */
+
+TEST_F(TBMBo, BoRef)
+{
+ tbm_bo bo;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo = tbm_bo_ref(bo);
+ 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);
+}
+
+TEST_F(TBMBo, BoRefWithBoParamTest)
+{
+ tbm_bo bo, invalid_bo;
+
+ bo = tbm_bo_ref(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);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_bo_unref() */
+
+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);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_bo_map() */
+
+TEST_F(TBMBo, BoMapUnmap)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
+ 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);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bo_unref(bo);
+}
+
+TEST_F(TBMBo, BoMapWithBoParamTest)
+{
+ tbm_bo invalid_bo;
+ tbm_bo_handle bo_handle;
+
+ bo_handle = tbm_bo_map(NULL, TBM_DEVICE_CPU, TBM_OPTION_READ);
+ 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);
+ 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??
+TEST_F(TBMBo, BoMapWithDeviceParamTest)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_handle = tbm_bo_map(bo, TBM_DEVICE_DEFAULT, TBM_OPTION_READ);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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)
+ EXPECT_NE(bo_handle.ptr, nullptr);
+ ret = tbm_bo_unmap(bo);
+ EXPECT_EQ(ret, 1);
+#endif
+
+ tbm_bo_unref(bo);
+}
+
+// TODO:: Use Value-Parameterized??
+TEST_F(TBMBo, BoMapWithOptParamTest)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bo_unref(bo);
+}
+
+/* tbm_bo_unmap() */
+
+TEST_F(TBMBo, BoUnmapWithBoParamTest)
+{
+ tbm_bo bo;
+ tbm_bo invalid_bo;
+ int ret;
+
+ ret = tbm_bo_unmap(NULL);
+ 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);
+ 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);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoGetHandle)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
+ 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);
+}
+
+TEST_F(TBMBo, BoGetHandleWithBoParamTest)
+{
+ tbm_bo_handle bo_handle;
+ tbm_bo invalid_bo;
+
+ bo_handle = tbm_bo_get_handle(NULL, TBM_DEVICE_DEFAULT);
+ 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);
+ 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)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_DEFAULT);
+ 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);
+ 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);
+ 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);
+ 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);
+ EXPECT_NE(bo_handle.ptr, nullptr);
+#endif
+
+ tbm_bo_unref(bo);
+}
+
+/* tbm_bo_export() */
+
+TEST_F(TBMBo, BoExport)
+{
+ tbm_bo bo;
+ tbm_key bo_key;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_key = tbm_bo_export(bo);
+ 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)
+{
+ tbm_bo invalid_bo;
+ tbm_key bo_key;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo_key = tbm_bo_export(NULL);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoExportFd)
+{
+ tbm_bo bo;
+ tbm_fd bo_fd;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo_fd = tbm_bo_export_fd(bo);
+ 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)
+{
+ tbm_bo invalid_bo;
+ tbm_fd bo_fd;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo_fd = tbm_bo_export_fd(NULL);
+ 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);
+ EXPECT_EQ(bo_fd, -1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_bo_import() */
+
+TEST_F(TBMBo, BoImport)
+{
+ tbm_bo bo1, bo2;
+ tbm_key bo_key;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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)
+{
+ tbm_bufmgr invalid_bufmgr;
+ tbm_bo bo;
+ tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo = tbm_bo_import(NULL, bo_key);
+ 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);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoImportWithKeyParamTest)
+{
+ tbm_bo bo;
+ tbm_key bo_key_invalid;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo_key_invalid = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
+ bo = tbm_bo_import(bufmgr, bo_key_invalid);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMBo, BoImportTwice)
+{
+ tbm_bo bo1, bo2, bo3;
+ tbm_key bo_key;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
+ return;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoImportFd)
+{
+ tbm_bo bo1, bo2;
+ tbm_fd bo_fd;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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)
+{
+ tbm_bufmgr invalid_bufmgr;
+ tbm_bo bo;
+ tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo = tbm_bo_import_fd(NULL, bo_fd);
+ 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);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoImportFdWithFdParamTest)
+{
+ tbm_bo bo;
+ tbm_fd bo_fd_invalid;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo_fd_invalid = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
+ bo = tbm_bo_import_fd(bufmgr, bo_fd_invalid);
+ EXPECT_EQ(bo, nullptr);
+ EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMBo, BoImportFdTwice)
+{
+ tbm_bo bo1, bo2, bo3;
+ tbm_fd bo_fd;
+
+ if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
+ return;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoSize)
+{
+ tbm_bo bo;
+ int size = 0;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ size = tbm_bo_size(bo);
+ 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)
+{
+ tbm_bo invalid_bo;
+ int size = 0;
+
+ size = tbm_bo_size(NULL);
+ 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);
+ EXPECT_EQ(size, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_bo_locked() */
+
+TEST_F(TBMBo, BoLocked)
+{
+ tbm_bo bo;
+ tbm_bo_handle bo_handle;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ ret = tbm_bo_unmap(bo);
+ 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);
+ 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)
+{
+ tbm_bo invalid_bo;
+ int ret;
+
+ ret = tbm_bo_locked(NULL);
+ 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);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+#if 0
+TEST_F(TBMBo, BoLockedOnce)
+{
+ // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
+ tbm_bo_handle bo_handle1, bo_handle2;
+ tbm_bo bo;
+ int ret_locked;
+
+ setenv("BUFMGR_LOCK_TYPE", "once", 1);
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ (void) bo_handle1;
+ (void) bo_handle2;
+
+ tbm_bo_unmap(bo);
+
+ ret_locked = tbm_bo_locked(bo);
+
+ tbm_bo_unmap(bo);
+
+ EXPECT_EQ(ret_locked, 0);
+}
+
+TEST_F(TBMBo, BoLockedAlways)
+{
+ // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
+ tbm_bo_handle bo_handle1, bo_handle2;
+ tbm_bo bo;
+ int ret_locked;
+
+ setenv("BUFMGR_LOCK_TYPE", "always", 1);
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ (void) bo_handle1;
+ (void) bo_handle2;
+
+ tbm_bo_unmap(bo);
+
+ ret_locked = tbm_bo_locked(bo);
+
+ tbm_bo_unmap(bo);
+
+ EXPECT_EQ(ret_locked, 1);
+}
+
+TEST_F(TBMBo, BoLockedNone)
+{
+ // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
+ tbm_bo_handle bo_handle1;
+ tbm_bo bo;
+ int ret_locked;
+
+ setenv("BUFMGR_LOCK_TYPE", "none", 1);
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(nullptr, bo);
+
+ bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
+ (void) bo_handle1;
+
+ ret_locked = tbm_bo_locked(bo);
+
+ tbm_bo_unmap(bo);
+
+ EXPECT_EQ(ret_locked, 0);
+}
+#endif
+
+/* tbm_bo_swap() */
+
+TEST_F(TBMBo, BoSwap)
+{
+ tbm_bo bo1, bo2;
+ int ret;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo1, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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)
+{
+ tbm_bo bo, invalid_bo1, invalid_bo2;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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;
+
+ bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(nullptr, bo1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE + 256, TBM_BO_DEFAULT);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoAddUserData)
+{
+ tbm_bo bo;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ ret = tbm_bo_add_user_data(bo, 4887, NULL);
+ 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)
+{
+ tbm_bo invalid_bo;
+ int ret;
+
+ ret = tbm_bo_add_user_data(NULL, 4887, NULL);
+ 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);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
+{
+ tbm_bo bo;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ ret = tbm_bo_add_user_data(bo, 4887, NULL);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoDeleteUserData)
+{
+ tbm_bo bo;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+
+ ret = tbm_bo_add_user_data(bo, 4887, NULL);
+ 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);
+ 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)
+{
+ tbm_bo invalid_bo;
+ int ret;
+
+ ret = tbm_bo_delete_user_data(NULL, 4887);
+ 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);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
+{
+ tbm_bo bo;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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);
+ 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() */
+
+static void
+_tc_tbm_bo_user_data_free(void *user_data)
+{
+ int *i = (int *)user_data;
+ *i = 1;
+}
+
+TEST_F(TBMBo, BoSetUserData)
+{
+ tbm_bo bo;
+ unsigned long key = 4887;
+ int data1 = 0, data2 = 0;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ ret = tbm_bo_add_user_data(bo, key, _tc_tbm_bo_user_data_free);
+ 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);
+ 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);
+ 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);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ 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)
+{
+ tbm_bo invalid_bo;
+ unsigned long key = 4887;
+ int data1 = 0, data2 = 0;
+ int ret;
+
+ ret = tbm_bo_set_user_data(NULL, key, &data1);
+ 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);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
+{
+ tbm_bo bo;
+ unsigned long key = 4887;
+ int data = 0;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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, _tc_tbm_bo_user_data_free);
+ 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);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoGetUserData)
+{
+ tbm_bo bo;
+ unsigned long key = 4887;
+ int data1 = 0;
+ int *data2;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ EXPECT_NE(bo, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ ret = tbm_bo_add_user_data(bo, key, NULL);
+ 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);
+ 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);
+ 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);
+ 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)
+{
+ tbm_bo invalid_bo;
+ unsigned long key = 4887;
+ int *data1;
+ int *data2;
+ int ret;
+
+ ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
+ 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);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
+{
+ tbm_bo bo;
+ unsigned long key = 4887;
+ int *data;
+ int ret;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
+ 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);
+ 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, _tc_tbm_bo_user_data_free);
+ 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);
+ 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);
+ 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);
+ 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() */
+
+TEST_F(TBMBo, BoGetFlags)
+{
+ tbm_bo bo;
+ int flags1 = TBM_BO_DEFAULT, flags2 = -1;
+
+ bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
+ 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);
+ 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)
+{
+ tbm_bo invalid_bo;
+ int flags = -1;
+
+ flags = tbm_bo_get_flags(NULL);
+ 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);
+ 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,
+ TBMBo,
+ Combine(Bool(), Bool(), Values("none")));
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+/* TODO::
+ * 1. Test When there is no bufmgr.
+ *
+ */
+TBMBufmgr::TBMBufmgr()
+{
+ bufmgr = NULL;
+}
+
+void TBMBufmgr::SetUp()
+{
+ TBMEnv::SetUp();
+
+ bufmgr = tbm_bufmgr_init(-1);
+ ASSERT_TRUE(bufmgr != NULL);
+}
+
+void TBMBufmgr::TearDown()
+{
+ tbm_bufmgr_deinit(bufmgr);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+
+ TBMEnv::TearDown();
+}
+
+/* tbm_bufmgr_get_capability() */
+TEST_F(TBMBufmgr, BufmgrGetCapability)
+{
+ unsigned int capability;
+
+ capability = tbm_bufmgr_get_capability(bufmgr);
+ EXPECT_NE(capability, TBM_BUFMGR_CAPABILITY_NONE);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMBufmgr, BufmgrGetCapabilityWithNullBufmgr)
+{
+ unsigned int capability;
+
+ capability = tbm_bufmgr_get_capability(NULL);
+ EXPECT_EQ(capability, TBM_BUFMGR_CAPABILITY_NONE);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
+{
+ tbm_bufmgr bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
+ unsigned int capability;
+
+ capability = tbm_bufmgr_get_capability(bufmgr);
+ EXPECT_EQ(capability, TBM_BUFMGR_CAPABILITY_NONE);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_bufmgr_bind_native_display() */
+#if 0 // TDDO:: fix the crash...
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplay)
+{
+ int ret;
+ void *native_display = (void *)UT_TBM_INVALID_VALUE;
+
+ ret = tbm_bufmgr_bind_native_display(bufmgr, native_display);
+ ASSERT_EQ(ret, 1);
+}
+
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
+{
+ int ret;
+ void *native_display = (void *)UT_TBM_INVALID_VALUE;
+
+ ret = tbm_bufmgr_bind_native_display(NULL, native_display);
+ ASSERT_EQ(ret, 0);
+}
+
+TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithWrongBufmgr)
+{
+ int ret;
+ void *native_display = (void *)UT_TBM_INVALID_VALUE;
+
+ ret = tbm_bufmgr_bind_native_display(NULL, native_display);
+ ASSERT_EQ(ret, 0);
+}
+#endif
+
+/* tbm_bufmgr_set_bo_lock_type() */
+TEST_F(TBMBufmgr, BufmgrSetBoLockType)
+{
+ int ret;
+
+ ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_ONCE);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS);
+ EXPECT_EQ(ret, 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMBufmgr, BufmgrSetBoLockTypeWithBufmgrParamTest)
+{
+ tbm_bufmgr invalid_bufmgr;
+ int ret;
+
+ ret = tbm_bufmgr_set_bo_lock_type(NULL, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
+ EXPECT_EQ(ret, 0);
+ invalid_bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
+ ret = tbm_bufmgr_set_bo_lock_type(invalid_bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
+ EXPECT_EQ(ret, 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+// TODO::::
+/* tbm_bufmgr_debug_show() */
+/* tbm_bufmgr_debug_tbm_info_get() */
+/* tbm_bufmgr_debug_trace() */
+/* tbm_bufmgr_debug_dump_all() */
+/* tbm_bufmgr_debug_queue_dump() */
+/* tbm_bufmgr_debug_dump_set_scale() */
+/* tbm_bufmgr_debug_get_ref_count */
+
+INSTANTIATE_TEST_CASE_P(TBMBufmgrParams,
+ TBMBufmgr,
+ Combine(Bool(), Bool(), Values("none")));
+
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+void TBMEnv::SetUp(void)
+{
+ setenv("XDG_RUNTIME_DIR", "/run", 1);
+ setenv("TBM_DISPLAY_SERVER", "1", 1);
+#if 0
+ const char *test_backend;
+
+ tdm_config_set_int(TBM_CONFIG_KEY_GENERAL_THREAD, ::testing::get<0>(GetParam()));
+ tdm_config_set_int(TBM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, ::testing::get<1>(GetParam()));
+ if (getenv("TBM_DEBUG_MODULE"))
+ tdm_config_set_string(TBM_CONFIG_KEY_DEBUG_MODULE, "buffer,thread,event,vblank,commit,pp,capture");
+
+ test_backend = ::testing::get<2>(GetParam());
+ if (!test_backend)
+ test_backend = TBM_DEFAULT_MODULE;
+ tdm_config_set_string(TBM_CONFIG_KEY_GENERAL_BACKENDS, test_backend);
+#endif
+}
+
+void TBMEnv::TearDown(void)
+{
+ unsetenv("XDG_RUNTIME_DIR");
+ unsetenv("TBM_DISPLAY_SERVER");
+}
+
+/* tbm_bufmgr_init(), tbm_bufmgr_deinit() */
+
+TEST_F(TBMEnv, BufmgrInitDeinit)
+{
+ tbm_bufmgr bufmgr;
+
+ bufmgr = tbm_bufmgr_init(-1);
+ EXPECT_NE(bufmgr, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bufmgr_deinit(bufmgr);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+TEST_F(TBMEnv, BufmgrInitWithoutEnv)
+{
+ tbm_bufmgr bufmgr;
+
+ TBMEnv::TearDown();
+
+ bufmgr = tbm_bufmgr_init(-1);
+ EXPECT_EQ(bufmgr, nullptr);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+TEST_F(TBMEnv, BufmgrInitFewTimes)
+{
+ tbm_bufmgr bufmgr[10];
+ int i;
+
+ for (i = 0; i < 10; i++) {
+ bufmgr[i] = tbm_bufmgr_init(-1);
+ EXPECT_NE(bufmgr[i], nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ }
+
+ for (i = 0; i < 10; i++)
+ tbm_bufmgr_deinit(bufmgr[i]);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+TEST_F(TBMEnv, BufmgrDeinitWithNULL)
+{
+ tbm_bufmgr_deinit(NULL);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+/* tbm_bufmgr_server_init() */
+TEST_F(TBMEnv, BufmgrServerInitDeinit)
+{
+ tbm_bufmgr bufmgr;
+
+ bufmgr = tbm_bufmgr_server_init();
+ EXPECT_NE(bufmgr, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bufmgr_deinit(bufmgr);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+TEST_F(TBMEnv, BufmgrServerInitWithoutEnv)
+{
+ tbm_bufmgr bufmgr;
+
+ TBMEnv::TearDown();
+
+ bufmgr = tbm_bufmgr_server_init();
+ EXPECT_NE(bufmgr, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_bufmgr_deinit(bufmgr);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+TEST_F(TBMEnv, BufmgrServerInitFewTimes)
+{
+ tbm_bufmgr bufmgr[10];
+ int i;
+
+ for (i = 0; i < 10; i++) {
+ bufmgr[i] = tbm_bufmgr_server_init();
+ EXPECT_NE(bufmgr[i], nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ }
+
+ for (i = 0; i < 10; i++)
+ tbm_bufmgr_deinit(bufmgr[i]);
+
+ ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
+}
+
+/* int tbm_surface_internal_query_supported_formats(uint32_t **formats, uint32_t *num) */
+TEST_F(TBMEnv, SurfaceInternalQueryFormats)
+{
+ tbm_bufmgr bufmgr;
+ uint32_t num = 0;
+ tbm_format *formats = NULL;
+
+ bufmgr = tbm_bufmgr_server_init();
+ EXPECT_NE(bufmgr, nullptr);
+
+ EXPECT_EQ(tbm_surface_internal_query_supported_formats(&formats, &num), 1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ EXPECT_GT(num, 0);
+ EXPECT_NE(formats, nullptr);
+ for (uint32_t i = 0; i < num; i++)
+ EXPECT_NE(formats[i], 0);
+
+ if (formats)
+ free(formats);
+
+ tbm_bufmgr_deinit(bufmgr);
+}
+
+TEST_F(TBMEnv, SurfaceInternalQueryFormatsFailNull)
+{
+ tbm_bufmgr bufmgr;
+ uint32_t num = 0;
+ tbm_format *formats = NULL;
+
+ bufmgr = tbm_bufmgr_server_init();
+ EXPECT_NE(bufmgr, nullptr);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ EXPECT_EQ(tbm_surface_internal_query_supported_formats(&formats, NULL), 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+ EXPECT_EQ(tbm_surface_internal_query_supported_formats(NULL, &num), 0);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ tbm_bufmgr_deinit(bufmgr);
+}
+
+TEST_F(TBMEnv, SurfaceQueryFormatsFailNull)
+{
+ uint32_t num = 0;
+ tbm_format *formats = NULL;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, NULL);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ result = (tbm_surface_error_e)tbm_surface_query_formats(NULL, &num);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMEnv, SurfaceQueryFormatSuccess)
+{
+ uint32_t num = 0;
+ tbm_format *formats = NULL;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num);
+ EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
+ EXPECT_GT(num, 0);
+ EXPECT_NE((tbm_format *)NULL, formats);
+ for (uint32_t i = 0; i < num; i++)
+ EXPECT_NE(0, formats[i]);
+ free(formats);
+}
+
+INSTANTIATE_TEST_CASE_P(TBMEnvParams,
+ TBMEnv,
+ Combine(Bool(), Bool(), Values("none")));
\ No newline at end of file
--- /dev/null
+
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+TEST(TBMLog, logPrintf)
+{
+ tbm_log_enable_color(1);
+ tbm_log_enable_dlog(0);
+ tbm_log_set_debug_level(2);
+ tbm_log_set_path("/tmp/tbm.log");
+ tbm_log_print(TBM_LOG_LEVEL_ERR, "haltest\n");
+ tbm_log_print(TBM_LOG_LEVEL_WRN, "haltest\n");
+ tbm_log_print(TBM_LOG_LEVEL_INFO, "haltest\n");
+ tbm_log_print(TBM_LOG_LEVEL_DBG, "haltest\n");
+ tbm_log_set_path(NULL);
+}
+
+TEST(TBMLog, logSetPath)
+{
+ tbm_log_enable_dlog(0);
+ tbm_log_set_path("/tmp/tbm.log");
+ tbm_log_print(TBM_LOG_LEVEL_ERR, "hello\n");
+ tbm_log_set_path(NULL);
+}
+
+TEST(TBMLog, logDlogNone)
+{
+ tbm_log_enable_color(0);
+ tbm_log_enable_dlog(1);
+ tbm_log_set_debug_level(0);
+ tbm_log_print(TBM_LOG_LEVEL_ERR, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_WRN, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_INFO, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_DBG, "haltest");
+}
+
+TEST(TBMLog, logDlog)
+{
+ tbm_log_enable_dlog(1);
+ tbm_log_print(TBM_LOG_LEVEL_ERR, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_WRN, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_INFO, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_DBG, "haltest");
+}
+
+TEST(TBMLog, logDlogNormal)
+{
+ tbm_log_enable_dlog(1);
+ tbm_log_print(TBM_LOG_LEVEL_ERR, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_WRN, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_INFO, "haltest");
+ tbm_log_print(TBM_LOG_LEVEL_DBG, "haltest");
+}
+
+TEST(TBMLog, logDlogUnknownLevel)
+{
+ tbm_log_enable_dlog(1);
+ tbm_log_print(UT_TBM_INVALID_VALUE, "haltest");
+}
+
+TEST(TBMLog, logSetAssertLevel)
+{
+ tbm_log_enable_dlog(1);
+ tbm_log_set_assert_level(TBM_LOG_LEVEL_ERR);
+ tbm_log_set_assert_level(TBM_LOG_LEVEL_WRN);
+ tbm_log_set_assert_level(TBM_LOG_LEVEL_INFO);
+ tbm_log_set_assert_level(TBM_LOG_LEVEL_DBG);
+}
+
+TEST(TBMLog, logPrintStdout)
+{
+ tbm_log_print_stdout(TBM_LOG_LEVEL_ERR, "haltest");
+ tbm_log_print_stdout(TBM_LOG_LEVEL_WRN, "haltest");
+ tbm_log_print_stdout(TBM_LOG_LEVEL_INFO, "haltest");
+ tbm_log_print_stdout(TBM_LOG_LEVEL_DBG, "haltest");
+}
\ No newline at end of file
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+/* The tbm_surface.h contains the public APIs. Therefore, the error values has TBM_SURFACE_ prefix,
+ * but the values of the TBM_SURFACE_ prefix error types has the same vaules as TBM_ERROR_ prefix types.
+ * We check the two error types in this TBMSurface testcase.
+ */
+
+class TBMSurface : public TBMBufmgr
+{
+protected:
+ void SetUp();
+ void TearDown();
+public:
+ uint32_t num_formats;
+ tbm_format *formats;
+ tbm_format format;
+
+ int width, height;
+ tbm_surface_h surface;
+};
+
+void TBMSurface::SetUp()
+{
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ TBMBufmgr::SetUp();
+
+ result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
+ ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
+
+ for (uint32_t i = 0; i < num_formats; i++)
+ if (formats[i] == TBM_FORMAT_ARGB8888)
+ format = TBM_FORMAT_ARGB8888;
+
+ /* fail if there is no TBM_FORMAT_ARGB8888 format */
+ ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
+
+ width = 720;
+ height = 1024;
+ surface = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_DEFAULT);
+ ASSERT_TRUE(surface != NULL);
+ ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+void TBMSurface::TearDown()
+{
+ if (surface)
+ tbm_surface_internal_destroy(surface);
+ ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ if (formats)
+ free(formats);
+
+ TBMBufmgr::TearDown();
+}
+
+TEST_F(TBMSurface, SurfaceCeateFailInvalidGeometry)
+{
+ tbm_surface_h surf1 = NULL;
+
+ surf1 = tbm_surface_create(-1, 1024, TBM_FORMAT_ARGB8888);
+ EXPECT_EQ(nullptr, surf1); // Expected Value: NULL
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ surf1 = tbm_surface_create(720, -1, TBM_FORMAT_ARGB8888);
+ EXPECT_EQ(nullptr, surf1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ surf1 = tbm_surface_create(720, 1024, 0);
+ EXPECT_EQ(nullptr, surf1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceCeateSuccess)
+{
+ tbm_surface_h surf1 = NULL;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ for (uint32_t i = 0; i < num_formats; i++) {
+ surf1 = tbm_surface_create(720, 1024, formats[i]);
+ EXPECT_NE((tbm_surface_h)NULL, surf1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ result = (tbm_surface_error_e)tbm_surface_destroy(surf1);
+ EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
+ EXPECT_EQ(TBM_ERROR_NONE, result);
+ }
+}
+
+TEST_F(TBMSurface, SurfaceGetFormatFailInvalidInput)
+{
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+ tbm_format fmt = tbm_surface_get_format(invalid_surface);
+ EXPECT_EQ(0, fmt);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetFormatFailNull)
+{
+ tbm_format fmt = tbm_surface_get_format(NULL);
+ EXPECT_EQ(0, fmt);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetFormatSuccess)
+{
+ tbm_format fmt = tbm_surface_get_format(surface);
+ EXPECT_EQ(this->format, fmt);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMSurface, SurfaceGetWidthFailInvalidInput)
+{
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+ int width = tbm_surface_get_width(invalid_surface);
+ EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetWidthFailNull)
+{
+ int width = tbm_surface_get_width(NULL);
+ EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetWidthSuccess)
+{
+ int width = tbm_surface_get_width(surface);
+ EXPECT_EQ(this->width, width);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMSurface, SurfaceGetHeightFailInvalidInput)
+{
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+ int height = tbm_surface_get_height(invalid_surface);
+ EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetHeightFailNull)
+{
+ int height = tbm_surface_get_height(NULL);
+ EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetHeightSuccess)
+{
+ int height = tbm_surface_get_height(surface);
+ EXPECT_EQ(this->height, height);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMSurface, SurfaceGetInfoInvalidInput)
+{
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_get_info(invalid_surface, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetInfoFailNull)
+{
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_get_info(surface, NULL);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ result = (tbm_surface_error_e)tbm_surface_get_info(NULL, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ result = (tbm_surface_error_e)tbm_surface_get_info(NULL, NULL);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceGetInfoSuccess)
+{
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
+ EXPECT_EQ(this->format, info.format);
+ EXPECT_EQ(this->height, info.height);
+ EXPECT_EQ(this->width, info.width);
+ EXPECT_GT(info.num_planes, 0);
+ EXPECT_GT(info.bpp, 0);
+ EXPECT_GT(info.size, 0);
+}
+
+TEST_F(TBMSurface, SurfaceMapFailInvalidInput)
+{
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+
+ result = (tbm_surface_error_e)tbm_surface_map(invalid_surface, 0, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceMapFailNull)
+{
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_map(surface, 0, NULL);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ result = (tbm_surface_error_e)tbm_surface_map(NULL, 0, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceMapSuccess)
+{
+ tbm_surface_info_s info;
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_map(surface, 0, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
+ EXPECT_EQ(this->format, info.format);
+ EXPECT_EQ(this->height, info.height);
+ EXPECT_EQ(this->width, info.width);
+ EXPECT_GT(info.num_planes, 0);
+ EXPECT_GT(info.bpp, 0);
+ EXPECT_GT(info.size, 0);
+
+ result = (tbm_surface_error_e)tbm_surface_unmap(surface);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMSurface, SurfaceUnmapFailInvalidInput)
+{
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+ tbm_surface_h invalid_surface = (tbm_surface_h)1;
+ result = (tbm_surface_error_e)tbm_surface_unmap(invalid_surface);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurface, SurfaceUnmapFailNull)
+{
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ result = (tbm_surface_error_e)tbm_surface_unmap(NULL);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+
+class TBMSurfaceInternal : public TBMBufmgr
+{
+protected:
+ void SetUp();
+ void TearDown();
+public:
+ uint32_t num_formats;
+ tbm_format *formats;
+ tbm_format argb8888_format;
+
+ tbm_surface_h surface;
+};
+
+void TBMSurfaceInternal::SetUp()
+{
+ int ret = 0;
+
+ TBMBufmgr::SetUp();
+
+ ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
+ ASSERT_TRUE(ret == 1);
+
+ for (uint32_t i = 0; i < num_formats; i++)
+ if (formats[i] == TBM_FORMAT_ARGB8888)
+ argb8888_format = TBM_FORMAT_ARGB8888;
+
+ /* fail if there is no TBM_FORMAT_ARGB8888 format */
+ ASSERT_TRUE(argb8888_format == TBM_FORMAT_ARGB8888);
+
+ surface = tbm_surface_internal_create_with_flags(720, 1024, argb8888_format, TBM_BO_DEFAULT);
+ ASSERT_TRUE(surface != NULL);
+}
+
+void TBMSurfaceInternal::TearDown()
+{
+ if (surface)
+ tbm_surface_internal_destroy(surface);
+
+ if (formats)
+ free(formats);
+
+ TBMBufmgr::TearDown();
+}
+
+/* tbm_surface_h tbm_surface_internal_create_with_flags(int width, int height, int format, int flags) */
+TEST_F(TBMSurfaceInternal, SurfaceInternalCeateDestroyTest)
+{
+ tbm_surface_h surface1 = NULL;
+
+ for (uint32_t i = 0; i < 1; i++) {
+ surface1 = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
+ EXPECT_NE(surface1, nullptr);
+ 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));
+ }
+}
+
+TEST_F(TBMSurfaceInternal, SurfaceInternalCeatewithParamsTest)
+{
+ tbm_surface_h surface1 = NULL;
+
+ surface1 = tbm_surface_internal_create_with_flags(-1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ 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);
+ 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);
+ 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));
+ 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)
+{
+ 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) */
+TEST_F(TBMSurfaceInternal, SurfaceInteranlIsValid)
+{
+ tbm_surface_h invalid_surface;
+
+ EXPECT_TRUE(tbm_surface_internal_is_valid(surface));
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ 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;
+ 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);
+ 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);
+ 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);
+ 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;
+
+ /* invalid surface */
+ bo = tbm_surface_internal_get_bo(invalide_surface, 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);
+ EXPECT_EQ(nullptr, bo);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceInternal, GetBoSuccess)
+{
+ tbm_bo bo = NULL;
+ int num = 0;
+
+ num = tbm_surface_internal_get_num_bos(surface);
+ 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);
+ EXPECT_NE(nullptr, bo);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+ }
+}
+
+/* tbm_surface_h tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, tbm_bo *bos, int num) */
+TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
+ 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);
+ 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);
+ EXPECT_EQ(nullptr, surf);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
+ EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
+
+ num = tbm_surface_internal_get_num_bos(surface);
+ EXPECT_GT(num, 0);
+
+ for (int i = 0; i < num; i++) {
+ bos[i] = tbm_surface_internal_get_bo(surface, 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);
+ 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);
+ 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);
+ EXPECT_EQ(nullptr, surf);
+ EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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));
+
+ EXPECT_FALSE(tbm_surface_internal_is_valid(surface)) ;
+
+ surface = NULL;
+}
+
+/* void tbm_surface_internal_ref(tbm_surface_h surface) */
+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);
+ 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() */
+TEST_F(TBMSurfaceInternal, GetNumPlanes)
+{
+ int num = 0;
+ num = tbm_surface_internal_get_num_planes(0);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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)
+{
+ 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;
+
+ 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;
+
+ 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));
+
+ 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));
+
+ 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) */
+TEST_F(TBMSurfaceInternal, GetBpp)
+{
+ int bpp = 0;
+ bpp = tbm_surface_internal_get_bpp(0);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ EXPECT_EQ(0, idx);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceInternal, GetPlaneBoIndexFailInvaildInput)
+{
+ int surf;
+ int idx;
+
+ idx = tbm_surface_internal_get_plane_bo_idx((tbm_surface_h)&surf, 0);
+ 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);
+ EXPECT_EQ(0, idx);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceInternal, GetPlaneBoIndexSuccess)
+{
+ int idx;
+
+ idx = tbm_surface_internal_get_plane_bo_idx(surface, 0);
+ 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;
+void data_free_handle(void *user_data)
+{
+ ASSERT_TRUE(user_data == &tbm_data_free_is_called);
+ int *is_called = (int *)user_data;
+ *is_called = 1;
+}
+
+/* tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key, tbm_data_free data_free_func) */
+TEST_F(TBMSurfaceInternal, AddUserDataFailNull)
+{
+ static const unsigned long key_ud = 0;
+ 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 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;
+ 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;
+ 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));
+
+ 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;
+ 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)
+{
+ static const unsigned long key_ud = 0;
+ int surf;
+
+ 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;
+ 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*/
+ 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;
+ 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;
+ 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) */
+TEST_F(TBMSurfaceInternal, GetUserDataFailNull)
+{
+ static const unsigned long key_ud = 0;
+ int *data = NULL;
+ 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));
+
+ 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)
+{
+ static const unsigned long key_ud = 0;
+ int surf;
+ int *data = NULL;
+
+ 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)
+{
+ unsigned long key_ud = 97456789;
+ int *data = NULL;
+
+ 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 */
+ 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 */
+ 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;
+ 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;
+ 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));
+
+ 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;
+
+ 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;
+ 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
--- /dev/null
+
+/**************************************************************************
+ *
+ * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
+ * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
+ * Contact: Roman Marchenko <r.marchenko@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+**************************************************************************/
+
+#include "tc_tbm.h"
+class TBMSurfaceQueue : public TBMBufmgr
+{
+protected:
+ void SetUp();
+ void TearDown();
+public:
+ int width;
+ int height;
+ int format;
+
+ uint32_t num_formats;
+ tbm_format *formats;
+
+ tbm_surface_h alien_surface;
+ tbm_surface_queue_h queue;
+
+ tbm_surface_queue_error_e result;
+ tbm_surface_h surface;
+};
+
+void TBMSurfaceQueue::SetUp()
+{
+ tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
+
+ TBMBufmgr::SetUp();
+
+ result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
+ EXPECT_STREQ(tbm_error_str(TBM_ERROR_NONE), tbm_error_str(result));
+
+ for (uint32_t i = 0; i < num_formats; i++)
+ if (formats[i] == TBM_FORMAT_ARGB8888)
+ format = TBM_FORMAT_ARGB8888;
+
+ /* fail if there is no TBM_FORMAT_ARGB8888 format */
+ ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
+
+ width = 720;
+ height = 1024;
+ alien_surface = tbm_surface_create(width, height, format);
+ EXPECT_NE((tbm_surface_h)NULL, alien_surface);
+
+ queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ EXPECT_NE((tbm_surface_queue_h)NULL, queue);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+void TBMSurfaceQueue::TearDown()
+{
+ if (alien_surface)
+ tbm_surface_destroy(alien_surface);
+
+ if (queue)
+ tbm_surface_queue_destroy(queue);
+
+ if (formats)
+ free(formats);
+
+ TBMBufmgr::TearDown();
+}
+
+static int memory_for_invalid_param;
+static tbm_surface_queue_h invalid_queue = (tbm_surface_queue_h)&memory_for_invalid_param;
+static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
+
+static int cb_data;
+static void tbm_surface_queue_event_handler(tbm_surface_queue_h surface_queue, void *data)
+{
+ if (data == &cb_data)
+ *((int *)data) = 1;
+}
+
+static tbm_surface_queue_trace trace_cb_data;
+static void tbm_surface_queue_trace_event_handler(tbm_surface_queue_h surface_queue,
+ tbm_surface_h surface, tbm_surface_queue_trace trace, void *data)
+{
+ if (data == &trace_cb_data)
+ trace_cb_data = trace;
+}
+
+static tbm_surface_h tbm_surface_alloc_cb_handler(tbm_surface_queue_h surface_queue, void *data)
+{
+ return (tbm_surface_h)data;
+}
+
+void tbm_surface_free_cb_handler(tbm_surface_queue_h surface_queue, void *data, tbm_surface_h surface)
+{
+ if (data == surface)
+ tbm_surface_destroy(surface);
+}
+
+TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
+{
+ tbm_surface_queue_h queue1 = NULL;
+
+ queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
+ EXPECT_NE(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_surface_queue_destroy(queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+/* tbm_surface_queue_h tbm_surface_queue_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
+ int height, int format, int flags); */
+TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
+{
+ tbm_surface_queue_h queue1 = NULL;
+
+ queue1 = tbm_surface_queue_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+/* tbm_surface_queue_h tbm_surface_queue_sequence_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
+ int height, int format, int flags); */
+TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
+{
+ tbm_surface_queue_h queue1 = NULL;
+
+ queue1 = tbm_surface_queue_sequence_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
+ EXPECT_EQ(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
+{
+ tbm_surface_queue_h queue1 = NULL;
+
+ queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
+ EXPECT_NE(nullptr, queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_surface_queue_destroy(queue1);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+
+/* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, DestroyNULL)
+{
+ tbm_surface_queue_destroy(NULL);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, DestroyTwice)
+{
+ tbm_surface_queue_destroy(queue);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+
+ tbm_surface_queue_destroy(queue);
+ EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+
+ /* to prevent destroy in TearDown */
+ queue = NULL;
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_dequeue(
+ tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
+TEST_F(TBMSurfaceQueue, DequeueFailNull)
+{
+ ASSERT_EXIT({
+ result = tbm_surface_queue_dequeue(NULL, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_dequeue(queue, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ exit(0);
+ }, ::testing::ExitedWithCode(0), "");
+}
+
+TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
+{
+ result = tbm_surface_queue_dequeue(invalid_queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, DequeueSuccess)
+{
+ /* do dequeue three times */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_NE((tbm_surface_h)NULL, surface);
+ }
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(nullptr, surface);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue,
+ tbm_surface_h *surfaces, int *num); */
+TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ int num;
+
+ result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_get_surfaces(queue, surfaces, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ int num;
+
+ result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+ int num = 0;
+
+ /* test: empty queue*/
+ result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(0, num);
+
+ /* do dequeue three times */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_NE(nullptr, surface);
+ }
+
+ /* test */
+ result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ EXPECT_NE(nullptr, surfaces[i]);
+
+ /* test: get only number of surfaces */
+ result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
+ tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
+TEST_F(TBMSurfaceQueue, CancelDequeueFailNull)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_dequeue(NULL, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_dequeue(queue, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, CancelDequeueFailInvaildInput)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+
+ result = tbm_surface_queue_cancel_dequeue(invalid_queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_dequeue(queue, invalid_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_dequeue(queue, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
+{
+ tbm_surface_h last_surface = NULL;
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_NE(nullptr, surface);
+ }
+
+ last_surface = surface;
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(nullptr, surface);
+
+ /* test */
+ result = tbm_surface_queue_cancel_dequeue(queue, last_surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(last_surface, surface);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_enqueue(
+ tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
+TEST_F(TBMSurfaceQueue, EnqueueFailNull)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_enqueue(NULL, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_enqueue(this->queue, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_enqueue(invalid_queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_enqueue(queue, invalid_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_enqueue(queue, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, EnqueueSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_enqueue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+}
+
+TEST_F(TBMSurfaceQueue, EnqueueFailTwice)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_acquire(
+ tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
+TEST_F(TBMSurfaceQueue, AcquireFailNull)
+{
+ /* test */
+ result = tbm_surface_queue_acquire(NULL, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AcquireFailInvaildInput)
+{
+ result = tbm_surface_queue_acquire(invalid_queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
+{
+ result = tbm_surface_queue_acquire(invalid_queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AcquireSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+ tbm_surface_h acquired_surface = NULL;
+
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_acquire(queue, &acquired_surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(surfaces[i], acquired_surface);
+ }
+
+ /* test: acquire empty queue*/
+ result = tbm_surface_queue_acquire(queue, &acquired_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(nullptr, acquired_surface);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
+ tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
+TEST_F(TBMSurfaceQueue, CancelAcquireFailNull)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+
+ /* test */
+ result = tbm_surface_queue_cancel_acquire(NULL, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_acquire(queue, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, CancelAcquireFailInvaildInput)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_cancel_acquire(invalid_queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_acquire(queue, invalid_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_cancel_acquire(queue, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
+{
+ tbm_surface_h last_surface = NULL;
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ last_surface = surface;
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(nullptr, surface);
+
+ /* test */
+ result = tbm_surface_queue_cancel_acquire(queue, last_surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(last_surface, surface);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_release(
+ tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
+TEST_F(TBMSurfaceQueue, ReleaseFailNull)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_release(NULL, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_release(this->queue, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_release(invalid_queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_release(queue, invalid_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_release(queue, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, ReleaseSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_release(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+}
+
+TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
+
+ /* create a sequence queue instead of a default one*/
+ tbm_surface_queue_destroy(queue);
+ queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_release(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+}
+
+TEST_F(TBMSurfaceQueue, ReleaseFailTwice)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_release(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_release(queue, surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+/* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, GetWidthFailNull)
+{
+ int width = tbm_surface_queue_get_width(NULL);
+ EXPECT_EQ(0, width);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetWidthFailInvalidInput)
+{
+ int width = tbm_surface_queue_get_width(invalid_queue);
+ EXPECT_EQ(0, width);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetWidthSuccess)
+{
+ int width = tbm_surface_queue_get_width(queue);
+ EXPECT_EQ(this->width, width);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+/* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, GetHeightFailNull)
+{
+ int height = tbm_surface_queue_get_height(NULL);
+ EXPECT_EQ(0, height);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetHeightFailInvalidInput)
+{
+ int height = tbm_surface_queue_get_height(invalid_queue);
+ EXPECT_EQ(0, height);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetHeightSuccess)
+{
+ int height = tbm_surface_queue_get_height(queue);
+ EXPECT_EQ(this->height, height);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+/* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, GetFormatFailNull)
+{
+ int format = tbm_surface_queue_get_format(NULL);
+ EXPECT_EQ(0, format);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetFormatFailInvalidInput)
+{
+ int format = tbm_surface_queue_get_format(invalid_queue);
+ EXPECT_EQ(0, format);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetFormatSuccess)
+{
+ int format = tbm_surface_queue_get_format(queue);
+ EXPECT_EQ((int)this->format, format);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+/* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, GetSizeFailNull)
+{
+ int q_size = tbm_surface_queue_get_size(NULL);
+ EXPECT_EQ(0, q_size);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
+{
+ int q_size = tbm_surface_queue_get_size(invalid_queue);
+ EXPECT_EQ(0, q_size);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
+}
+
+TEST_F(TBMSurfaceQueue, GetSizeSuccess)
+{
+ int q_size = tbm_surface_queue_get_size(queue);
+ EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, q_size);
+ EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_reset(
+ tbm_surface_queue_h surface_queue, int width, int height, int format); */
+TEST_F(TBMSurfaceQueue, ResetFailNull)
+{
+ result = tbm_surface_queue_reset(NULL, width, height, format);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, ResetFailInvalidInput)
+{
+ result = tbm_surface_queue_reset(invalid_queue, width, height, format);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_reset(invalid_queue, -1, height, format);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_reset(invalid_queue, width, -1, format);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_reset(invalid_queue, width, height, 0);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, ResetSuccessEmptyQueue)
+{
+ result = tbm_surface_queue_reset(queue, width-10, height-10, format);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
+{
+ tbm_surface_h surface = NULL;
+
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_reset(queue, width, height, format);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
+}
+
+TEST_F(TBMSurfaceQueue, ResetSuccess)
+{
+ tbm_surface_h surface = NULL;
+
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
+}
+
+TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
+{
+ tbm_surface_h surface = NULL;
+
+ /* create a sequence queue instead of a default one*/
+ tbm_surface_queue_destroy(queue);
+ queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
+ ASSERT_TRUE(queue != NULL);
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_set_size(
+ tbm_surface_queue_h surface_queue, int UT_TBM_SURFACE_QUEUE_SIZE, int flush); */
+TEST_F(TBMSurfaceQueue, SetSizeFailNull)
+{
+ result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
+{
+ result = tbm_surface_queue_set_size(invalid_queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_set_size(NULL, 0, 0);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
+{
+ tbm_surface_h surface = NULL;
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*test: */
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
+
+ /*test: with flush*/
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 1);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
+}
+
+TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
+{
+ tbm_surface_h surface = NULL;
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*test: */
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+1, 0);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
+
+ /*test: with flush*/
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+2, 1);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
+}
+
+TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
+{
+ tbm_surface_h surface = NULL;
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*test: */
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-1, 0);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
+
+ /*test: with flush*/
+ result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-2, 1);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, FlushFailNull)
+{
+ result = tbm_surface_queue_flush(NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
+{
+ result = tbm_surface_queue_flush(invalid_queue);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, FlushSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+
+ /*test: flushing not initialized queue*/
+ result = tbm_surface_queue_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ result = tbm_surface_queue_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, FreeFlushFailNull)
+{
+ result = tbm_surface_queue_free_flush(NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
+{
+ result = tbm_surface_queue_free_flush(invalid_queue);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
+{
+ tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
+
+ /*test: flushing not initialized queue*/
+ result = tbm_surface_queue_free_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+
+ /* init queue */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
+ result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ result = tbm_surface_queue_free_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* extra check */
+ for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
+ ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddResetCbFailNull)
+{
+ result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_reset_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddResetCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
+ cb_data = 0;
+ result = tbm_surface_queue_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveResetCbFailNull)
+{
+ result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_enqueue(queue, surface);
+ result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+
+ /* test */
+ result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
+ cb_data = 0;
+ result = tbm_surface_queue_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 0);
+}
+
+TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_enqueue(queue, surface);
+ result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+
+ /* test: invalid queue*/
+ result = tbm_surface_queue_remove_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test: invalid data */
+ result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, NULL);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test: invalid cb function */
+ result = tbm_surface_queue_remove_reset_cb(queue, (tbm_surface_queue_notify_cb)1, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
+ cb_data = 0;
+ result = tbm_surface_queue_flush(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, NotifyResetFailNull)
+{
+ result = tbm_surface_queue_notify_reset(NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, NotifyResetFailInvalidInput)
+{
+ result = tbm_surface_queue_notify_reset(invalid_queue);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
+{
+ result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ cb_data = 0;
+ result = tbm_surface_queue_notify_reset(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue); */
+TEST_F(TBMSurfaceQueue, NotifyDequeuableFailNull)
+{
+ result = tbm_surface_queue_notify_dequeuable(NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, NotifyDequeuableFailInvalidInput)
+{
+ result = tbm_surface_queue_notify_dequeuable(invalid_queue);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, NotifyDequeuableCbSuccess)
+{
+ /* test */
+ result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_notify_dequeuable(queue);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */
+TEST_F(TBMSurfaceQueue, CanDequeueFailNull)
+{
+ ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0));
+}
+
+TEST_F(TBMSurfaceQueue, CanDequeueFailInvalidInput)
+{
+ ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0));
+}
+
+TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
+{
+ int dq_count = 0;
+
+ /* test: dequeue all*/
+ while (tbm_surface_queue_can_dequeue(queue, 0)) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ dq_count++;
+ }
+ EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
+}
+
+TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
+{
+ /*Dequeue all*/
+ while (tbm_surface_queue_can_dequeue(queue, 0)) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ }
+
+ /* test */
+ ASSERT_FALSE(tbm_surface_queue_can_dequeue(queue, 0));
+}
+
+
+/* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */
+TEST_F(TBMSurfaceQueue, CanAcquireFailNull)
+{
+ ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0));
+}
+
+TEST_F(TBMSurfaceQueue, CanAcquireFailInvalidInput)
+{
+ ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0));
+}
+
+TEST_F(TBMSurfaceQueue, CanAcquireFailEmptyQueue)
+{
+ ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0));
+}
+
+TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
+{
+ int acq_count = 0;
+
+ while (tbm_surface_queue_can_dequeue(queue, 0)) {
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ }
+
+ /*Dequeue all*/
+ while (tbm_surface_queue_can_acquire(queue, 0)) {
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ acq_count++;
+ }
+
+ EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddDestroyCbFailNull)
+{
+ result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_destroy_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDestroyCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
+{
+ /* test */
+ result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ tbm_surface_queue_destroy(queue);
+ ASSERT_TRUE(cb_data == 1);
+
+ /* to avoid destroying queue in TearDown*/
+ queue = NULL;
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailNull)
+{
+ result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailInvalidInput)
+{
+ result = tbm_surface_queue_remove_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
+{
+ result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_remove_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ tbm_surface_queue_destroy(queue);
+ ASSERT_TRUE(cb_data == 0);
+
+ /* to avoid destroying queue in TearDown*/
+ queue = NULL;
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddDequeuableCbFailNull)
+{
+ result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_dequeuable_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDequeuableCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_release(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailNull)
+{
+ result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailInvalidInput)
+{
+ /* test: invalid queue */
+ result = tbm_surface_queue_remove_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_remove_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_release(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 0);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddDequeueCbFailNull)
+{
+ result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_dequeue_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDequeueCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
+{
+ /* test */
+ result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailNull)
+{
+ result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailInvalidInput)
+{
+ /* test: invalid queue */
+ result = tbm_surface_queue_remove_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
+{
+ /* test */
+ result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+
+ result = tbm_surface_queue_remove_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 0);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailNull)
+{
+ result = tbm_surface_queue_add_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_can_dequeue_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
+{
+ /* test */
+ result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailNull)
+{
+ result = tbm_surface_queue_remove_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailInvalidInput)
+{
+ /* test: invalid queue */
+ result = tbm_surface_queue_remove_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
+{
+ result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_remove_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
+ ASSERT_TRUE(cb_data == 0);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddAcquirableCbFailNull)
+{
+ result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_acquirable_cb(queue, NULL, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddAcquirableCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
+{
+ tbm_surface_queue_dequeue(queue, &surface);
+
+ /* test */
+ result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 1);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailNull)
+{
+ result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailInvalidInput)
+{
+ /* test: invalid queue */
+ result = tbm_surface_queue_remove_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_remove_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ cb_data = 0;
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(cb_data == 0);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
+TEST_F(TBMSurfaceQueue, AddTraceCbFailNull)
+{
+ result = tbm_surface_queue_add_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_add_trace_cb(queue, NULL, &trace_cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddTraceCbFailInvalidInput)
+{
+ result = tbm_surface_queue_add_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
+{
+ trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
+
+ /* test */
+ result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
+
+ result = tbm_surface_queue_cancel_dequeue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE);
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
+
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
+
+ result = tbm_surface_queue_cancel_acquire(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE);
+
+ result = tbm_surface_queue_acquire(queue, &surface);
+ result = tbm_surface_queue_release(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_RELEASE);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
+TEST_F(TBMSurfaceQueue, RemoveTraceCbFailNull)
+{
+ result = tbm_surface_queue_remove_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveTraceCbFailInvalidInput)
+{
+ /* test: invalid queue */
+ result = tbm_surface_queue_remove_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
+{
+ trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
+
+ result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test */
+ result = tbm_surface_queue_remove_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_NONE);
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb( tbm_surface_queue_h surface_queue,
+ tbm_surface_alloc_cb alloc_cb, tbm_surface_free_cb free_cb, void *data); */
+TEST_F(TBMSurfaceQueue, SetAllocCbFailNull)
+{
+ result = tbm_surface_queue_set_alloc_cb(NULL, tbm_surface_alloc_cb_handler,
+ tbm_surface_free_cb_handler, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetAllocCbFailInvalidInput)
+{
+ result = tbm_surface_queue_set_alloc_cb(invalid_queue, tbm_surface_alloc_cb_handler,
+ tbm_surface_free_cb_handler, alien_surface);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetAllocCbSuccess)
+{
+ result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler,
+ tbm_surface_free_cb_handler, alien_surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test: allocate */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(alien_surface, surface);
+
+ /* test: alien_surface has to be deleted*/
+ tbm_surface_queue_destroy(queue);
+ ASSERT_FALSE(tbm_surface_internal_is_valid(alien_surface));
+
+ alien_surface = NULL;
+}
+
+/* tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num(
+ tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num); */
+TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailNull)
+{
+ int num = 0;
+
+ ASSERT_EXIT({
+
+ result = tbm_surface_queue_get_trace_surface_num(NULL, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, NULL);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ exit(0);
+ }, ::testing::ExitedWithCode(0), "");
+
+}
+
+TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailInvalidInput)
+{
+ int num = 0;
+
+ result = tbm_surface_queue_get_trace_surface_num(invalid_queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
+{
+ int num = 0;
+
+ result = tbm_surface_queue_set_size(queue, 4, 0);
+
+ /* one acquired */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_enqueue(queue, surface);
+ result = tbm_surface_queue_acquire(queue, &surface);
+
+ /* one enqueued */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_enqueue(queue, surface);
+
+ /* one dequeued */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+
+ /* one released */
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ result = tbm_surface_queue_cancel_dequeue(queue, surface);
+
+
+ /* test */
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(0, num);
+
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(1, num);
+
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ENQUEUE, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(1, num);
+
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ACQUIRE, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(1, num);
+
+ result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_RELEASE, &num);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+ EXPECT_EQ(1, num);
+}
+/* tbm_surface_queue_error_e tbm_surface_queue_set_modes(
+ tbm_surface_queue_h surface_queue, int modes); */
+TEST_F(TBMSurfaceQueue, SetModesFailNull)
+{
+ result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetModesFailInvalidInput)
+{
+ result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetModesSuccess)
+{
+ result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+/* tbm_surface_queue_set_sync_count() */
+TEST_F(TBMSurfaceQueue, SetSyncCountFailNull)
+{
+ result = tbm_surface_queue_set_sync_count(NULL, 1);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetSyncCountFailInvalidInput)
+{
+ result = tbm_surface_queue_set_sync_count(invalid_queue, 1);
+ EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
+
+TEST_F(TBMSurfaceQueue, SetSyncCountSuccess)
+{
+ result = tbm_surface_queue_dequeue(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test: map after enqueue */
+ result = tbm_surface_queue_set_sync_count(queue, 0);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_enqueue(queue, surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ /* test: map after acquire */
+ result = tbm_surface_queue_set_sync_count(queue, 0);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+
+ result = tbm_surface_queue_acquire(queue, &surface);
+ EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
+}
\ No newline at end of file
%bcond_with x
%bcond_with wayland
-%define UTEST_PACKAGE 1
-%define UTEST_GCOV 0
+%define HALTESTS_PACKAGE 1
+%define HALTESTS_GCOV 0
Name: libtbm
Version: 2.13.1
BuildRequires: pkgconfig(libpng)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(pixman-1)
-BuildRequires: gtest-devel
+BuildRequires: gtest-devel
%description
Description: %{summary}
Development Files.
-%if "%{UTEST_PACKAGE}" == "1"
+%if "%{HALTESTS_PACKAGE}" == "1"
%package haltests
Summary: Tizen Buffer Manager unit tests package
Group: System/Libraries
cp %{SOURCE1001} .
%build
-UTEST="no"
+HALTESTS="no"
-%if "%{UTEST_PACKAGE}" == "1"
-UTEST="yes"
+%if "%{HALTESTS_PACKAGE}" == "1"
+HALTESTS="yes"
%endif
-%if "%{UTEST_GCOV}" == "1"
+%if "%{HALTESTS_GCOV}" == "1"
CFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV"
CXXFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV"
LDFLAGS+=" -lgcov"
%endif
%if %{with wayland}
-%reconfigure --prefix=%{_prefix} --with-tbm-platform=WAYLAND --with-utests=${UTEST} \
+%reconfigure --prefix=%{_prefix} --with-tbm-platform=WAYLAND --with-haltests=${HALTESTS} \
CFLAGS="${CFLAGS} -Wall -Werror" LDFLAGS="${LDFLAGS} -Wl,--hash-style=both -Wl,--as-needed"
%else
-%reconfigure --prefix=%{_prefix} --with-tbm-platform=X11 --with-utests=${UTEST} \
+%reconfigure --prefix=%{_prefix} --with-tbm-platform=X11 --with-haltests=${HALTESTS} \
CFLAGS="${CFLAGS} -Wall -Werror" LDFLAGS="${LDFLAGS} -Wl,--hash-style=both -Wl,--as-needed"
%endif
%{_libdir}/libtbm.so
%{_libdir}/pkgconfig/libtbm.pc
-%if "%{UTEST_PACKAGE}" == "1"
+%if "%{HALTESTS_PACKAGE}" == "1"
%files haltests
%defattr(-,root,root,-)
-%{_bindir}/tbm-utests
+%{_bindir}/tbm-haltests
%endif
+++ /dev/null
-bin_PROGRAMS = tbm-utests
-
-tbm_utests_SOURCES = \
- ut_main.cpp \
- ut_tbm_env.cpp \
- ut_tbm_bufmgr.cpp \
- ut_tbm_bo.cpp \
- ut_tbm_surface.cpp \
- ut_tbm_surface_internal.cpp \
- ut_tbm_surface_queue.cpp \
- ut_tbm_backend.cpp \
- ut_tbm_log.cpp
-
-tbm_utests_CXXFLAGS = \
- @DLOG_CFLAGS@ \
- ${CXXFLAGS} \
- -I$(top_builddir)/src \
- -I$(includedir)/gtest
-
-tbm_utests_LDFLAGS = \
- @DLOG_LIBS@ \
- ${LDFLAGS} \
- $(top_builddir)/src/libtbm.la \
- -lgtest \
- -pthread
-
-check:
- ./tbm-utests
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "gtest/gtest.h"
-
-#ifdef TIZEN_TEST_GCOV
-extern "C" void __gcov_flush(void);
-#endif
-
-int main(int argc, char **argv)
-{
- auto AllTestSuccess = false;
-
-#ifdef TIZEN_TEST_GCOV
- setenv("GCOV_PREFIX", "/tmp", 1);
-#endif
-
- try {
- ::testing::InitGoogleTest(&argc, argv);
- ::testing::FLAGS_gtest_death_test_style = "fast";
- } catch ( ... ) {
- std::cout << "error while trying to init google tests.\n";
- exit(EXIT_FAILURE);
- }
-
- try {
- AllTestSuccess = RUN_ALL_TESTS() == 0 ? true : false;
- } catch (const ::testing::internal::GoogleTestFailureException & e) {
- AllTestSuccess = false;
- std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;
- std::cout << "\n";
- }
-
-#ifdef TIZEN_TEST_GCOV
- __gcov_flush();
-#endif
-
- return AllTestSuccess;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#ifndef UT_H
-#define UT_H
-
-#include <vector>
-#include <list>
-#include <climits>
-#include <pthread.h>
-#include <gtest/gtest.h>
-#include <stdlib.h>
-#include <tbm_bufmgr_int.h>
-#include <wayland-server-protocol.h>
-
-#define TBM_UT_ENTRY() \
- TBM_INFO("--------------------------------------------- %s", typeid(*this).name())
-
-#define TBM_UT_CHECK_FLAG(FLAG) \
- do {\
- if(!(FLAG)) \
- TBM_INFO("[ ] not supported");\
- } while(0)
-
-#define TBM_UT_SKIP_FLAG(FLAG) \
- do {\
- if(!(FLAG)) {\
- TBM_INFO("[ SKIPPED ] not supported");\
- return;\
- }\
- } while(0)
-
-#define TBM_UT_NEVER_GET_HERE() \
- do {\
- TBM_INFO("!!! TBM UT NEVER GET HERE !!!");\
- } while(0)
-#define TBM_UT_RETURN_IF_FAIL(cond) { \
- if (!(cond)) { \
- TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
- return; \
- } \
-}
-#define TBM_UT_RETURN_FALSE_IF_FAIL(cond) { \
- if (!(cond)) { \
- TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
- return false; \
- } \
-}
-#define TBM_UT_GOTO_IF_FAIL(cond, dst) { \
- if (!(cond)) { \
- TBM_ERR("[%s,%d] '%s' failed", __FUNCTION__, __LINE__, #cond); \
- goto dst; \
- } \
-}
-
-#define TBM_UT_DUMP_DIR "/tmp/tbm_dump"
-#define UT_TBM_INVALID_VALUE -42
-#define TBM_UT_INVALID_UINT_VALUE 99999
-#define UT_TBM_BO_SIZE 1024
-#define UT_TBM_SURFACE_QUEUE_SIZE 4
-
-using ::testing::TestWithParam;
-using ::testing::Bool;
-using ::testing::Values;
-using ::testing::Combine;
-
-class TBMEnv : public TestWithParam< ::testing::tuple<bool, bool, const char*> >
-{
-public:
- void SetUp(void);
- void TearDown(void);
-};
-
-class TBMBufmgr : public TBMEnv
-{
-public:
- TBMBufmgr();
- void SetUp(void);
- void TearDown(void);
-
- tbm_bufmgr bufmgr;
-};
-
-#endif // UT_H
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: SooChan Lim <sc1.lim@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-#define UT_TBM_ITER_COUNT 100
-
-class TBMBackend : public TBMEnv
-{
-public:
- void SetUp(void);
- void TearDown(void);
-};
-
-void TBMBackend::SetUp()
-{
- TBMEnv::SetUp();
-}
-
-void TBMBackend::TearDown()
-{
- TBMEnv::TearDown();
-}
-
-// bufmgr init, deinit
-TEST_F(TBMBackend, BufmgrInitDeinit)
-{
- tbm_bufmgr bufmgr;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- tbm_bufmgr_deinit(bufmgr);
-}
-
-// backend symbol check
-TEST_F(TBMBackend, BufmgrCheckSymbols)
-{
- tbm_bufmgr bufmgr;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- // check backend symbols
- if (bufmgr->backend_module_data) {
- EXPECT_TRUE(bufmgr->backend_module_data->init);
- EXPECT_TRUE(bufmgr->backend_module_data->deinit);
-
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_capabilities);
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_bind_native_display);
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_supported_formats);
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_plane_data);
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_alloc_bo);
- if (!bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format)
- printf("No bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format symbole.\n");
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_fd);
- EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_key);
-
- EXPECT_TRUE(bufmgr->bo_func->bo_free);
- EXPECT_TRUE(bufmgr->bo_func->bo_get_size);
- EXPECT_TRUE(bufmgr->bo_func->bo_get_memory_types);
- EXPECT_TRUE(bufmgr->bo_func->bo_get_handle);
- EXPECT_TRUE(bufmgr->bo_func->bo_map);
- EXPECT_TRUE(bufmgr->bo_func->bo_unmap);
- if (!bufmgr->bo_func->bo_lock)
- printf("No bufmgr->bo_func->bo_lock symbole.\n");
- if (!bufmgr->bo_func->bo_unlock)
- printf("No bufmgr->bo_func->bo_unlock symbole.\n");
- EXPECT_TRUE(bufmgr->bo_func->bo_export_fd);
- EXPECT_TRUE(bufmgr->bo_func->bo_export_key);
- } else {
- EXPECT_TRUE(bufmgr->backend->priv);
- EXPECT_TRUE(bufmgr->backend->bufmgr_deinit);
- EXPECT_TRUE(bufmgr->backend->bufmgr_bind_native_display);
- EXPECT_TRUE(bufmgr->backend->bo_alloc);
- EXPECT_TRUE(bufmgr->backend->bo_free);
- EXPECT_TRUE(bufmgr->backend->bo_size);
- EXPECT_TRUE(bufmgr->backend->bo_get_flags);
- EXPECT_TRUE(bufmgr->backend->bo_get_handle);
- EXPECT_TRUE(bufmgr->backend->bo_map && bufmgr->backend->bo_unmap);
- if (!bufmgr->backend->bo_lock)
- printf("No bufmgr->backend->bo_lock symbole.\n");
- if (!bufmgr->backend->bo_unlock)
- printf("No bufmgr->backend->bo_unlock symbole.\n");
- EXPECT_TRUE(bufmgr->backend->bo_import_fd && bufmgr->backend->bo_export_fd);
- EXPECT_TRUE(bufmgr->backend->bo_import && bufmgr->backend->bo_export);
- EXPECT_TRUE(bufmgr->backend->surface_supported_format);
- if (!bufmgr->backend->surface_bo_alloc)
- printf("No bufmgr->backend->surface_bo_alloc symbole.\n");
- EXPECT_TRUE(bufmgr->backend->surface_get_plane_data);
- }
-
- tbm_bufmgr_deinit(bufmgr);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// bo_alloc, bo_free, bo_size test
-TEST_F(TBMBackend, BufmgrBindNativeDisplay)
-{
- tbm_bufmgr bufmgr;
- struct wl_display *native_display = NULL;
- int ret;
-
- native_display = wl_display_create();
- assert(native_display != NULL);
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- ret = wl_display_add_socket(native_display, "ut-tbm-socket");
- EXPECT_TRUE(ret == 0);
-
- ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
- EXPECT_TRUE(ret == 1);
-
- tbm_bufmgr_deinit(bufmgr);
-
- wl_display_destroy(native_display);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// bo_alloc, bo_free, bo_size test
-TEST_F(TBMBackend, BoAllocFree)
-{
- tbm_bufmgr bufmgr;
- tbm_bo bo[UT_TBM_ITER_COUNT];
- int i, alloc_size, ret_size;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- // bufmgr->backend->bo_alloc
- for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
- alloc_size = 10 * i + 1;
- bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
- EXPECT_TRUE(bo[i] != NULL);
-
- // bufmgr->backend->bo_size
- ret_size = tbm_bo_size(bo[i]);
- if (alloc_size != ret_size)
- printf("The alloc_size is different from return value of the tbm_bo_size().");
- }
-
- // bufmgr->backend->bo_free
- for (i = 0; i < UT_TBM_ITER_COUNT; i++)
- tbm_bo_unref(bo[i]);
-
- tbm_bufmgr_deinit(bufmgr);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
-TEST_F(TBMBackend, BoGetHandleMapUnmap)
-{
- tbm_bufmgr bufmgr;
- tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
- tbm_bo bo[UT_TBM_ITER_COUNT];
- int i, j, alloc_size, ret_size;
- int ret = 0;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- // bufmgr->backend->bo_alloc
- for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
- alloc_size = 10 * i + 1;
- bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
- EXPECT_TRUE(bo[i] != NULL);
-
- // bufmgr->backend->bo_size
- ret_size = tbm_bo_size(bo[i]);
- if (alloc_size != ret_size)
- printf("The alloc_size is different from return value of the tbm_bo_size().");
-
- for (j = TBM_DEVICE_DEFAULT; j <= TBM_DEVICE_3D; j++) {
- bo_handle[i] = tbm_bo_get_handle(bo[i], j);
- EXPECT_TRUE(bo_handle[i].ptr != NULL);
- bo_handle[i] = tbm_bo_map(bo[i], j, TBM_OPTION_READ|TBM_OPTION_WRITE);
- EXPECT_TRUE(bo_handle[i].ptr != NULL);
- ret = tbm_bo_unmap(bo[i]);
- EXPECT_TRUE(ret == 1);
- }
- }
-
- // bufmgr->backend->bo_free
- for (i = 0; i < UT_TBM_ITER_COUNT; i++)
- tbm_bo_unref(bo[i]);
-
- tbm_bufmgr_deinit(bufmgr);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// bo_export_fd, bo_import_fd
-TEST_F(TBMBackend, BoExportImportFd)
-{
- tbm_bufmgr bufmgr;
- tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
- tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
- tbm_bo bo[UT_TBM_ITER_COUNT];
- tbm_bo import_bo[UT_TBM_ITER_COUNT];
- tbm_fd fd[UT_TBM_ITER_COUNT];
- int i, alloc_size;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- // bufmgr->backend->bo_alloc
- for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
- alloc_size = 10 * i + 1;
- bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
- EXPECT_TRUE(bo[i] != NULL);
-
- bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
- EXPECT_TRUE(bo_handle[i].ptr != NULL);
-
- fd[i] = tbm_bo_export_fd(bo[i]);
- EXPECT_TRUE(fd[i] >= 0);
-
- import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
- EXPECT_TRUE(import_bo[i] != NULL);
-
- import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
- EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
- }
-
- // bufmgr->backend->bo_free
- for (i = 0; i < UT_TBM_ITER_COUNT; i++)
- tbm_bo_unref(bo[i]);
-
- tbm_bufmgr_deinit(bufmgr);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// bo_export, bo_import
-TEST_F(TBMBackend, BoExportImport)
-{
- tbm_bufmgr bufmgr;
- tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
- tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
- tbm_bo bo[UT_TBM_ITER_COUNT];
- tbm_bo import_bo[UT_TBM_ITER_COUNT];
- tbm_key key[UT_TBM_ITER_COUNT];
- int i, alloc_size;
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-
- // bufmgr->backend->bo_alloc
- for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
- alloc_size = 10 * i + 1;
- bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
- EXPECT_TRUE(bo[i] != NULL);
-
- bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
- EXPECT_TRUE(bo_handle[i].ptr != NULL);
-
- key[i] = tbm_bo_export(bo[i]);
- EXPECT_TRUE(key[i] != 0);
-
- import_bo[i] = tbm_bo_import(bufmgr, key[i]);
- EXPECT_TRUE(import_bo[i] != NULL);
-
- import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
- EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
- }
-
- // bufmgr->backend->bo_free
- for (i = 0; i < UT_TBM_ITER_COUNT; i++)
- tbm_bo_unref(bo[i]);
-
- tbm_bufmgr_deinit(bufmgr);
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// surface_supported_format
-TEST_F(TBMBackend, SurfaceSupportedFormat)
-{
- uint32_t num_formats = 0;
- tbm_format *formats = NULL;
- int format = -1;
- int ret = 0;
-
- ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
- EXPECT_TRUE(ret == 1);
- EXPECT_TRUE(formats != NULL);
-
- for (uint32_t i = 0; i < num_formats; i++)
- if (formats[i] == TBM_FORMAT_ARGB8888)
- format = TBM_FORMAT_ARGB8888;
-
- /* fail if there is no TBM_FORMAT_ARGB8888 format */
- EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
-
- free(formats);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-// surface_bo_alloc, surface_get_plane_data
-TEST_F(TBMBackend, SurfaceBoAlloc)
-{
- uint32_t num_formats = 0;
- tbm_format *formats = NULL;
- int ret = 0;
- tbm_surface_h surface;
-
- ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
- EXPECT_TRUE(ret == 1);
- EXPECT_TRUE(formats != NULL);
-
- for (uint32_t i = 0; i < num_formats; i++) {
- surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
- EXPECT_TRUE(surface != NULL);
- tbm_surface_internal_destroy(surface);
- }
-
- free(formats);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-
-
+++ /dev/null
-
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-class TBMBo : public TBMBufmgr
-{
-public:
- TBMBo();
- void SetUp(void);
- void TearDown(void);
-
- unsigned int bufmgr_capability;
-};
-
-TBMBo::TBMBo()
-{
- bufmgr_capability = TBM_BUFMGR_CAPABILITY_NONE;
-}
-
-void TBMBo::SetUp()
-{
- TBMBufmgr::SetUp();
-
- bufmgr_capability = tbm_bufmgr_get_capability(bufmgr);
- EXPECT_TRUE(bufmgr_capability != TBM_BUFMGR_CAPABILITY_NONE);
-}
-
-void TBMBo::TearDown()
-{
- TBMBufmgr::TearDown();
-}
-
-/* tbm_bo_alloc() */
-
-TEST_F(TBMBo, BoAllocUnref)
-{
- tbm_bo bo;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bo_unref(bo);
-}
-
-TEST_F(TBMBo, BoAllocWithBufmgrParamTest)
-{
- tbm_bo bo;
- tbm_bufmgr invalid_bufmgr;
-
- invalid_bufmgr = NULL;
- bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- invalid_bufmgr = (tbm_bufmgr)TBM_UT_INVALID_UINT_VALUE;
- bo = tbm_bo_alloc(invalid_bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoAllocWithSizeParamTest)
-{
- tbm_bo bo;
-
- bo = tbm_bo_alloc(bufmgr, -1, TBM_BO_DEFAULT);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoAllocWithFlagsParamTest)
-{
- tbm_bo bo;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- tbm_bo_unref(bo);
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_SCANOUT);
- 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);
- 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);
- 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_ref() */
-
-TEST_F(TBMBo, BoRef)
-{
- tbm_bo bo;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo = tbm_bo_ref(bo);
- 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);
-}
-
-TEST_F(TBMBo, BoRefWithBoParamTest)
-{
- tbm_bo bo, invalid_bo;
-
- bo = tbm_bo_ref(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);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_bo_unref() */
-
-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);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_bo_map() */
-
-TEST_F(TBMBo, BoMapUnmap)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
- 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);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bo_unref(bo);
-}
-
-TEST_F(TBMBo, BoMapWithBoParamTest)
-{
- tbm_bo invalid_bo;
- tbm_bo_handle bo_handle;
-
- bo_handle = tbm_bo_map(NULL, TBM_DEVICE_CPU, TBM_OPTION_READ);
- 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);
- 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??
-TEST_F(TBMBo, BoMapWithDeviceParamTest)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_handle = tbm_bo_map(bo, TBM_DEVICE_DEFAULT, TBM_OPTION_READ);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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)
- EXPECT_NE(bo_handle.ptr, nullptr);
- ret = tbm_bo_unmap(bo);
- EXPECT_EQ(ret, 1);
-#endif
-
- tbm_bo_unref(bo);
-}
-
-// TODO:: Use Value-Parameterized??
-TEST_F(TBMBo, BoMapWithOptParamTest)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
- 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);
- 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);
- 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);
- 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);
- 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);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bo_unref(bo);
-}
-
-/* tbm_bo_unmap() */
-
-TEST_F(TBMBo, BoUnmapWithBoParamTest)
-{
- tbm_bo bo;
- tbm_bo invalid_bo;
- int ret;
-
- ret = tbm_bo_unmap(NULL);
- 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);
- 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);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoGetHandle)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
- 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);
-}
-
-TEST_F(TBMBo, BoGetHandleWithBoParamTest)
-{
- tbm_bo_handle bo_handle;
- tbm_bo invalid_bo;
-
- bo_handle = tbm_bo_get_handle(NULL, TBM_DEVICE_DEFAULT);
- 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);
- 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)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_DEFAULT);
- 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);
- 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);
- 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);
- 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);
- EXPECT_NE(bo_handle.ptr, nullptr);
-#endif
-
- tbm_bo_unref(bo);
-}
-
-/* tbm_bo_export() */
-
-TEST_F(TBMBo, BoExport)
-{
- tbm_bo bo;
- tbm_key bo_key;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_key = tbm_bo_export(bo);
- 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)
-{
- tbm_bo invalid_bo;
- tbm_key bo_key;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo_key = tbm_bo_export(NULL);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoExportFd)
-{
- tbm_bo bo;
- tbm_fd bo_fd;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo_fd = tbm_bo_export_fd(bo);
- 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)
-{
- tbm_bo invalid_bo;
- tbm_fd bo_fd;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo_fd = tbm_bo_export_fd(NULL);
- 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);
- EXPECT_EQ(bo_fd, -1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_bo_import() */
-
-TEST_F(TBMBo, BoImport)
-{
- tbm_bo bo1, bo2;
- tbm_key bo_key;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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)
-{
- tbm_bufmgr invalid_bufmgr;
- tbm_bo bo;
- tbm_key bo_key = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo = tbm_bo_import(NULL, bo_key);
- 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);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoImportWithKeyParamTest)
-{
- tbm_bo bo;
- tbm_key bo_key_invalid;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo_key_invalid = (tbm_key)TBM_UT_INVALID_UINT_VALUE;
- bo = tbm_bo_import(bufmgr, bo_key_invalid);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMBo, BoImportTwice)
-{
- tbm_bo bo1, bo2, bo3;
- tbm_key bo_key;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_KEY))
- return;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoImportFd)
-{
- tbm_bo bo1, bo2;
- tbm_fd bo_fd;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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)
-{
- tbm_bufmgr invalid_bufmgr;
- tbm_bo bo;
- tbm_fd bo_fd = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo = tbm_bo_import_fd(NULL, bo_fd);
- 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);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoImportFdWithFdParamTest)
-{
- tbm_bo bo;
- tbm_fd bo_fd_invalid;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo_fd_invalid = (tbm_fd)TBM_UT_INVALID_UINT_VALUE;
- bo = tbm_bo_import_fd(bufmgr, bo_fd_invalid);
- EXPECT_EQ(bo, nullptr);
- EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMBo, BoImportFdTwice)
-{
- tbm_bo bo1, bo2, bo3;
- tbm_fd bo_fd;
-
- if (!(bufmgr_capability & TBM_BUFMGR_CAPABILITY_SHARE_FD))
- return;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoSize)
-{
- tbm_bo bo;
- int size = 0;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- size = tbm_bo_size(bo);
- 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)
-{
- tbm_bo invalid_bo;
- int size = 0;
-
- size = tbm_bo_size(NULL);
- 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);
- EXPECT_EQ(size, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_bo_locked() */
-
-TEST_F(TBMBo, BoLocked)
-{
- tbm_bo bo;
- tbm_bo_handle bo_handle;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- ret = tbm_bo_unmap(bo);
- 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);
- 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)
-{
- tbm_bo invalid_bo;
- int ret;
-
- ret = tbm_bo_locked(NULL);
- 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);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-#if 0
-TEST_F(TBMBo, BoLockedOnce)
-{
- // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
- tbm_bo_handle bo_handle1, bo_handle2;
- tbm_bo bo;
- int ret_locked;
-
- setenv("BUFMGR_LOCK_TYPE", "once", 1);
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- (void) bo_handle1;
- (void) bo_handle2;
-
- tbm_bo_unmap(bo);
-
- ret_locked = tbm_bo_locked(bo);
-
- tbm_bo_unmap(bo);
-
- EXPECT_EQ(ret_locked, 0);
-}
-
-TEST_F(TBMBo, BoLockedAlways)
-{
- // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
- tbm_bo_handle bo_handle1, bo_handle2;
- tbm_bo bo;
- int ret_locked;
-
- setenv("BUFMGR_LOCK_TYPE", "always", 1);
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- (void) bo_handle1;
- (void) bo_handle2;
-
- tbm_bo_unmap(bo);
-
- ret_locked = tbm_bo_locked(bo);
-
- tbm_bo_unmap(bo);
-
- EXPECT_EQ(ret_locked, 1);
-}
-
-TEST_F(TBMBo, BoLockedNone)
-{
- // TODO: need to be fixed. use tbm_bufmgr_set_bo_lock_type instead of BUFMGR_LOCK_TYPE
- tbm_bo_handle bo_handle1;
- tbm_bo bo;
- int ret_locked;
-
- setenv("BUFMGR_LOCK_TYPE", "none", 1);
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(nullptr, bo);
-
- bo_handle1 = tbm_bo_map(bo, TBM_DEVICE_2D, TBM_OPTION_READ | TBM_OPTION_WRITE);
- (void) bo_handle1;
-
- ret_locked = tbm_bo_locked(bo);
-
- tbm_bo_unmap(bo);
-
- EXPECT_EQ(ret_locked, 0);
-}
-#endif
-
-/* tbm_bo_swap() */
-
-TEST_F(TBMBo, BoSwap)
-{
- tbm_bo bo1, bo2;
- int ret;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo1, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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)
-{
- tbm_bo bo, invalid_bo1, invalid_bo2;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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;
-
- bo1 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(nullptr, bo1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- bo2 = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE + 256, TBM_BO_DEFAULT);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoAddUserData)
-{
- tbm_bo bo;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- ret = tbm_bo_add_user_data(bo, 4887, NULL);
- 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)
-{
- tbm_bo invalid_bo;
- int ret;
-
- ret = tbm_bo_add_user_data(NULL, 4887, NULL);
- 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);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoAddUserDataSameKeyTwiceTest)
-{
- tbm_bo bo;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- ret = tbm_bo_add_user_data(bo, 4887, NULL);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoDeleteUserData)
-{
- tbm_bo bo;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
-
- ret = tbm_bo_add_user_data(bo, 4887, NULL);
- 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);
- 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)
-{
- tbm_bo invalid_bo;
- int ret;
-
- ret = tbm_bo_delete_user_data(NULL, 4887);
- 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);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoDeleteUserDataWithKeyParam)
-{
- tbm_bo bo;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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() */
-
-static void
-_ut_tbm_bo_user_data_free(void *user_data)
-{
- int *i = (int *)user_data;
- *i = 1;
-}
-
-TEST_F(TBMBo, BoSetUserData)
-{
- tbm_bo bo;
- unsigned long key = 4887;
- int data1 = 0, data2 = 0;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- ret = tbm_bo_add_user_data(bo, key, _ut_tbm_bo_user_data_free);
- 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);
- 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);
- 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);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- 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)
-{
- tbm_bo invalid_bo;
- unsigned long key = 4887;
- int data1 = 0, data2 = 0;
- int ret;
-
- ret = tbm_bo_set_user_data(NULL, key, &data1);
- 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);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoSetUserDataWithKeyParamTest)
-{
- tbm_bo bo;
- unsigned long key = 4887;
- int data = 0;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoGetUserData)
-{
- tbm_bo bo;
- unsigned long key = 4887;
- int data1 = 0;
- int *data2;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- EXPECT_NE(bo, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- ret = tbm_bo_add_user_data(bo, key, NULL);
- 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);
- 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);
- 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);
- 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)
-{
- tbm_bo invalid_bo;
- unsigned long key = 4887;
- int *data1;
- int *data2;
- int ret;
-
- ret = tbm_bo_get_user_data(NULL, key, (void **)&data1);
- 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);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBo, BoGetUserDataWithKeyParamTest)
-{
- tbm_bo bo;
- unsigned long key = 4887;
- int *data;
- int ret;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, TBM_BO_DEFAULT);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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() */
-
-TEST_F(TBMBo, BoGetFlags)
-{
- tbm_bo bo;
- int flags1 = TBM_BO_DEFAULT, flags2 = -1;
-
- bo = tbm_bo_alloc(bufmgr, UT_TBM_BO_SIZE, flags1);
- 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);
- 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)
-{
- tbm_bo invalid_bo;
- int flags = -1;
-
- flags = tbm_bo_get_flags(NULL);
- 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);
- 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,
- TBMBo,
- Combine(Bool(), Bool(), Values("none")));
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-/* TODO::
- * 1. Test When there is no bufmgr.
- *
- */
-TBMBufmgr::TBMBufmgr()
-{
- bufmgr = NULL;
-}
-
-void TBMBufmgr::SetUp()
-{
- TBMEnv::SetUp();
-
- bufmgr = tbm_bufmgr_init(-1);
- ASSERT_TRUE(bufmgr != NULL);
-}
-
-void TBMBufmgr::TearDown()
-{
- tbm_bufmgr_deinit(bufmgr);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-
- TBMEnv::TearDown();
-}
-
-/* tbm_bufmgr_get_capability() */
-TEST_F(TBMBufmgr, BufmgrGetCapability)
-{
- unsigned int capability;
-
- capability = tbm_bufmgr_get_capability(bufmgr);
- EXPECT_NE(capability, TBM_BUFMGR_CAPABILITY_NONE);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMBufmgr, BufmgrGetCapabilityWithNullBufmgr)
-{
- unsigned int capability;
-
- capability = tbm_bufmgr_get_capability(NULL);
- EXPECT_EQ(capability, TBM_BUFMGR_CAPABILITY_NONE);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMBufmgr, BufmgrGetCapabilityWithWrongBufmgr)
-{
- tbm_bufmgr bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
- unsigned int capability;
-
- capability = tbm_bufmgr_get_capability(bufmgr);
- EXPECT_EQ(capability, TBM_BUFMGR_CAPABILITY_NONE);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_bufmgr_bind_native_display() */
-#if 0 // TDDO:: fix the crash...
-TEST_F(TBMBufmgr, BufmgrBindNativeDisplay)
-{
- int ret;
- void *native_display = (void *)UT_TBM_INVALID_VALUE;
-
- ret = tbm_bufmgr_bind_native_display(bufmgr, native_display);
- ASSERT_EQ(ret, 1);
-}
-
-TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithNullBufmgr)
-{
- int ret;
- void *native_display = (void *)UT_TBM_INVALID_VALUE;
-
- ret = tbm_bufmgr_bind_native_display(NULL, native_display);
- ASSERT_EQ(ret, 0);
-}
-
-TEST_F(TBMBufmgr, BufmgrBindNativeDisplayWithWrongBufmgr)
-{
- int ret;
- void *native_display = (void *)UT_TBM_INVALID_VALUE;
-
- ret = tbm_bufmgr_bind_native_display(NULL, native_display);
- ASSERT_EQ(ret, 0);
-}
-#endif
-
-/* tbm_bufmgr_set_bo_lock_type() */
-TEST_F(TBMBufmgr, BufmgrSetBoLockType)
-{
- int ret;
-
- ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_ONCE);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- ret = tbm_bufmgr_set_bo_lock_type(bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_ALWAYS);
- EXPECT_EQ(ret, 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMBufmgr, BufmgrSetBoLockTypeWithBufmgrParamTest)
-{
- tbm_bufmgr invalid_bufmgr;
- int ret;
-
- ret = tbm_bufmgr_set_bo_lock_type(NULL, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
- EXPECT_EQ(ret, 0);
- invalid_bufmgr = (tbm_bufmgr)UT_TBM_INVALID_VALUE;
- ret = tbm_bufmgr_set_bo_lock_type(invalid_bufmgr, TBM_BUFMGR_BO_LOCK_TYPE_NEVER);
- EXPECT_EQ(ret, 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-// TODO::::
-/* tbm_bufmgr_debug_show() */
-/* tbm_bufmgr_debug_tbm_info_get() */
-/* tbm_bufmgr_debug_trace() */
-/* tbm_bufmgr_debug_dump_all() */
-/* tbm_bufmgr_debug_queue_dump() */
-/* tbm_bufmgr_debug_dump_set_scale() */
-/* tbm_bufmgr_debug_get_ref_count */
-
-INSTANTIATE_TEST_CASE_P(TBMBufmgrParams,
- TBMBufmgr,
- Combine(Bool(), Bool(), Values("none")));
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-void TBMEnv::SetUp(void)
-{
- setenv("XDG_RUNTIME_DIR", "/run", 1);
- setenv("TBM_DISPLAY_SERVER", "1", 1);
-#if 0
- const char *test_backend;
-
- tdm_config_set_int(TBM_CONFIG_KEY_GENERAL_THREAD, ::testing::get<0>(GetParam()));
- tdm_config_set_int(TBM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, ::testing::get<1>(GetParam()));
- if (getenv("TBM_DEBUG_MODULE"))
- tdm_config_set_string(TBM_CONFIG_KEY_DEBUG_MODULE, "buffer,thread,event,vblank,commit,pp,capture");
-
- test_backend = ::testing::get<2>(GetParam());
- if (!test_backend)
- test_backend = TBM_DEFAULT_MODULE;
- tdm_config_set_string(TBM_CONFIG_KEY_GENERAL_BACKENDS, test_backend);
-#endif
-}
-
-void TBMEnv::TearDown(void)
-{
- unsetenv("XDG_RUNTIME_DIR");
- unsetenv("TBM_DISPLAY_SERVER");
-}
-
-/* tbm_bufmgr_init(), tbm_bufmgr_deinit() */
-
-TEST_F(TBMEnv, BufmgrInitDeinit)
-{
- tbm_bufmgr bufmgr;
-
- bufmgr = tbm_bufmgr_init(-1);
- EXPECT_NE(bufmgr, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bufmgr_deinit(bufmgr);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-TEST_F(TBMEnv, BufmgrInitWithoutEnv)
-{
- tbm_bufmgr bufmgr;
-
- TBMEnv::TearDown();
-
- bufmgr = tbm_bufmgr_init(-1);
- EXPECT_EQ(bufmgr, nullptr);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-TEST_F(TBMEnv, BufmgrInitFewTimes)
-{
- tbm_bufmgr bufmgr[10];
- int i;
-
- for (i = 0; i < 10; i++) {
- bufmgr[i] = tbm_bufmgr_init(-1);
- EXPECT_NE(bufmgr[i], nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- }
-
- for (i = 0; i < 10; i++)
- tbm_bufmgr_deinit(bufmgr[i]);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-TEST_F(TBMEnv, BufmgrDeinitWithNULL)
-{
- tbm_bufmgr_deinit(NULL);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-/* tbm_bufmgr_server_init() */
-TEST_F(TBMEnv, BufmgrServerInitDeinit)
-{
- tbm_bufmgr bufmgr;
-
- bufmgr = tbm_bufmgr_server_init();
- EXPECT_NE(bufmgr, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bufmgr_deinit(bufmgr);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-TEST_F(TBMEnv, BufmgrServerInitWithoutEnv)
-{
- tbm_bufmgr bufmgr;
-
- TBMEnv::TearDown();
-
- bufmgr = tbm_bufmgr_server_init();
- EXPECT_NE(bufmgr, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_bufmgr_deinit(bufmgr);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-TEST_F(TBMEnv, BufmgrServerInitFewTimes)
-{
- tbm_bufmgr bufmgr[10];
- int i;
-
- for (i = 0; i < 10; i++) {
- bufmgr[i] = tbm_bufmgr_server_init();
- EXPECT_NE(bufmgr[i], nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- }
-
- for (i = 0; i < 10; i++)
- tbm_bufmgr_deinit(bufmgr[i]);
-
- ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
-}
-
-/* int tbm_surface_internal_query_supported_formats(uint32_t **formats, uint32_t *num) */
-TEST_F(TBMEnv, SurfaceInternalQueryFormats)
-{
- tbm_bufmgr bufmgr;
- uint32_t num = 0;
- tbm_format *formats = NULL;
-
- bufmgr = tbm_bufmgr_server_init();
- EXPECT_NE(bufmgr, nullptr);
-
- EXPECT_EQ(tbm_surface_internal_query_supported_formats(&formats, &num), 1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- EXPECT_GT(num, 0);
- EXPECT_NE(formats, nullptr);
- for (uint32_t i = 0; i < num; i++)
- EXPECT_NE(formats[i], 0);
-
- if (formats)
- free(formats);
-
- tbm_bufmgr_deinit(bufmgr);
-}
-
-TEST_F(TBMEnv, SurfaceInternalQueryFormatsFailNull)
-{
- tbm_bufmgr bufmgr;
- uint32_t num = 0;
- tbm_format *formats = NULL;
-
- bufmgr = tbm_bufmgr_server_init();
- EXPECT_NE(bufmgr, nullptr);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- EXPECT_EQ(tbm_surface_internal_query_supported_formats(&formats, NULL), 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
- EXPECT_EQ(tbm_surface_internal_query_supported_formats(NULL, &num), 0);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- tbm_bufmgr_deinit(bufmgr);
-}
-
-TEST_F(TBMEnv, SurfaceQueryFormatsFailNull)
-{
- uint32_t num = 0;
- tbm_format *formats = NULL;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, NULL);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- result = (tbm_surface_error_e)tbm_surface_query_formats(NULL, &num);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMEnv, SurfaceQueryFormatSuccess)
-{
- uint32_t num = 0;
- tbm_format *formats = NULL;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num);
- EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
- EXPECT_GT(num, 0);
- EXPECT_NE((tbm_format *)NULL, formats);
- for (uint32_t i = 0; i < num; i++)
- EXPECT_NE(0, formats[i]);
- free(formats);
-}
-
-INSTANTIATE_TEST_CASE_P(TBMEnvParams,
- TBMEnv,
- Combine(Bool(), Bool(), Values("none")));
\ No newline at end of file
+++ /dev/null
-
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-TEST(TBMLog, logPrintf)
-{
- tbm_log_enable_color(1);
- tbm_log_enable_dlog(0);
- tbm_log_set_debug_level(2);
- tbm_log_set_path("/tmp/tbm.log");
- tbm_log_print(TBM_LOG_LEVEL_ERR, "utest\n");
- tbm_log_print(TBM_LOG_LEVEL_WRN, "utest\n");
- tbm_log_print(TBM_LOG_LEVEL_INFO, "utest\n");
- tbm_log_print(TBM_LOG_LEVEL_DBG, "utest\n");
- tbm_log_set_path(NULL);
-}
-
-TEST(TBMLog, logSetPath)
-{
- tbm_log_enable_dlog(0);
- tbm_log_set_path("/tmp/tbm.log");
- tbm_log_print(TBM_LOG_LEVEL_ERR, "hello\n");
- tbm_log_set_path(NULL);
-}
-
-TEST(TBMLog, logDlogNone)
-{
- tbm_log_enable_color(0);
- tbm_log_enable_dlog(1);
- tbm_log_set_debug_level(0);
- tbm_log_print(TBM_LOG_LEVEL_ERR, "utest");
- tbm_log_print(TBM_LOG_LEVEL_WRN, "utest");
- tbm_log_print(TBM_LOG_LEVEL_INFO, "utest");
- tbm_log_print(TBM_LOG_LEVEL_DBG, "utest");
-}
-
-TEST(TBMLog, logDlog)
-{
- tbm_log_enable_dlog(1);
- tbm_log_print(TBM_LOG_LEVEL_ERR, "utest");
- tbm_log_print(TBM_LOG_LEVEL_WRN, "utest");
- tbm_log_print(TBM_LOG_LEVEL_INFO, "utest");
- tbm_log_print(TBM_LOG_LEVEL_DBG, "utest");
-}
-
-TEST(TBMLog, logDlogNormal)
-{
- tbm_log_enable_dlog(1);
- tbm_log_print(TBM_LOG_LEVEL_ERR, "utest");
- tbm_log_print(TBM_LOG_LEVEL_WRN, "utest");
- tbm_log_print(TBM_LOG_LEVEL_INFO, "utest");
- tbm_log_print(TBM_LOG_LEVEL_DBG, "utest");
-}
-
-TEST(TBMLog, logDlogUnknownLevel)
-{
- tbm_log_enable_dlog(1);
- tbm_log_print(UT_TBM_INVALID_VALUE, "utest");
-}
-
-TEST(TBMLog, logSetAssertLevel)
-{
- tbm_log_enable_dlog(1);
- tbm_log_set_assert_level(TBM_LOG_LEVEL_ERR);
- tbm_log_set_assert_level(TBM_LOG_LEVEL_WRN);
- tbm_log_set_assert_level(TBM_LOG_LEVEL_INFO);
- tbm_log_set_assert_level(TBM_LOG_LEVEL_DBG);
-}
-
-TEST(TBMLog, logPrintStdout)
-{
- tbm_log_print_stdout(TBM_LOG_LEVEL_ERR, "utest");
- tbm_log_print_stdout(TBM_LOG_LEVEL_WRN, "utest");
- tbm_log_print_stdout(TBM_LOG_LEVEL_INFO, "utest");
- tbm_log_print_stdout(TBM_LOG_LEVEL_DBG, "utest");
-}
\ No newline at end of file
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-/* The tbm_surface.h contains the public APIs. Therefore, the error values has TBM_SURFACE_ prefix,
- * but the values of the TBM_SURFACE_ prefix error types has the same vaules as TBM_ERROR_ prefix types.
- * We check the two error types in this TBMSurface testcase.
- */
-
-class TBMSurface : public TBMBufmgr
-{
-protected:
- void SetUp();
- void TearDown();
-public:
- uint32_t num_formats;
- tbm_format *formats;
- tbm_format format;
-
- int width, height;
- tbm_surface_h surface;
-};
-
-void TBMSurface::SetUp()
-{
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- TBMBufmgr::SetUp();
-
- result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
- ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- ASSERT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
-
- for (uint32_t i = 0; i < num_formats; i++)
- if (formats[i] == TBM_FORMAT_ARGB8888)
- format = TBM_FORMAT_ARGB8888;
-
- /* fail if there is no TBM_FORMAT_ARGB8888 format */
- ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
-
- width = 720;
- height = 1024;
- surface = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_DEFAULT);
- ASSERT_TRUE(surface != NULL);
- ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-void TBMSurface::TearDown()
-{
- if (surface)
- tbm_surface_internal_destroy(surface);
- ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- ASSERT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- if (formats)
- free(formats);
-
- TBMBufmgr::TearDown();
-}
-
-TEST_F(TBMSurface, SurfaceCeateFailInvalidGeometry)
-{
- tbm_surface_h surf1 = NULL;
-
- surf1 = tbm_surface_create(-1, 1024, TBM_FORMAT_ARGB8888);
- EXPECT_EQ(nullptr, surf1); // Expected Value: NULL
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- surf1 = tbm_surface_create(720, -1, TBM_FORMAT_ARGB8888);
- EXPECT_EQ(nullptr, surf1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- surf1 = tbm_surface_create(720, 1024, 0);
- EXPECT_EQ(nullptr, surf1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceCeateSuccess)
-{
- tbm_surface_h surf1 = NULL;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- for (uint32_t i = 0; i < num_formats; i++) {
- surf1 = tbm_surface_create(720, 1024, formats[i]);
- EXPECT_NE((tbm_surface_h)NULL, surf1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- result = (tbm_surface_error_e)tbm_surface_destroy(surf1);
- EXPECT_EQ(TBM_SURFACE_ERROR_NONE, result);
- EXPECT_EQ(TBM_ERROR_NONE, result);
- }
-}
-
-TEST_F(TBMSurface, SurfaceGetFormatFailInvalidInput)
-{
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
- tbm_format fmt = tbm_surface_get_format(invalid_surface);
- EXPECT_EQ(0, fmt);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetFormatFailNull)
-{
- tbm_format fmt = tbm_surface_get_format(NULL);
- EXPECT_EQ(0, fmt);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetFormatSuccess)
-{
- tbm_format fmt = tbm_surface_get_format(surface);
- EXPECT_EQ(this->format, fmt);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMSurface, SurfaceGetWidthFailInvalidInput)
-{
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
- int width = tbm_surface_get_width(invalid_surface);
- EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetWidthFailNull)
-{
- int width = tbm_surface_get_width(NULL);
- EXPECT_EQ(width, TBM_SURFACE_ERROR_INVALID_PARAMETER);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetWidthSuccess)
-{
- int width = tbm_surface_get_width(surface);
- EXPECT_EQ(this->width, width);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMSurface, SurfaceGetHeightFailInvalidInput)
-{
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
- int height = tbm_surface_get_height(invalid_surface);
- EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetHeightFailNull)
-{
- int height = tbm_surface_get_height(NULL);
- EXPECT_EQ(height, TBM_SURFACE_ERROR_INVALID_PARAMETER);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetHeightSuccess)
-{
- int height = tbm_surface_get_height(surface);
- EXPECT_EQ(this->height, height);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMSurface, SurfaceGetInfoInvalidInput)
-{
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_get_info(invalid_surface, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetInfoFailNull)
-{
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_get_info(surface, NULL);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- result = (tbm_surface_error_e)tbm_surface_get_info(NULL, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- result = (tbm_surface_error_e)tbm_surface_get_info(NULL, NULL);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceGetInfoSuccess)
-{
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_get_info(surface, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
- EXPECT_EQ(this->format, info.format);
- EXPECT_EQ(this->height, info.height);
- EXPECT_EQ(this->width, info.width);
- EXPECT_GT(info.num_planes, 0);
- EXPECT_GT(info.bpp, 0);
- EXPECT_GT(info.size, 0);
-}
-
-TEST_F(TBMSurface, SurfaceMapFailInvalidInput)
-{
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
-
- result = (tbm_surface_error_e)tbm_surface_map(invalid_surface, 0, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceMapFailNull)
-{
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_map(surface, 0, NULL);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- result = (tbm_surface_error_e)tbm_surface_map(NULL, 0, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceMapSuccess)
-{
- tbm_surface_info_s info;
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_map(surface, 0, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
- EXPECT_EQ(this->format, info.format);
- EXPECT_EQ(this->height, info.height);
- EXPECT_EQ(this->width, info.width);
- EXPECT_GT(info.num_planes, 0);
- EXPECT_GT(info.bpp, 0);
- EXPECT_GT(info.size, 0);
-
- result = (tbm_surface_error_e)tbm_surface_unmap(surface);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_NONE));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMSurface, SurfaceUnmapFailInvalidInput)
-{
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
- tbm_surface_h invalid_surface = (tbm_surface_h)1;
- result = (tbm_surface_error_e)tbm_surface_unmap(invalid_surface);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurface, SurfaceUnmapFailNull)
-{
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- result = (tbm_surface_error_e)tbm_surface_unmap(NULL);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_SURFACE_ERROR_INVALID_PARAMETER));
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-
-class TBMSurfaceInternal : public TBMBufmgr
-{
-protected:
- void SetUp();
- void TearDown();
-public:
- uint32_t num_formats;
- tbm_format *formats;
- tbm_format argb8888_format;
-
- tbm_surface_h surface;
-};
-
-void TBMSurfaceInternal::SetUp()
-{
- int ret = 0;
-
- TBMBufmgr::SetUp();
-
- ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
- ASSERT_TRUE(ret == 1);
-
- for (uint32_t i = 0; i < num_formats; i++)
- if (formats[i] == TBM_FORMAT_ARGB8888)
- argb8888_format = TBM_FORMAT_ARGB8888;
-
- /* fail if there is no TBM_FORMAT_ARGB8888 format */
- ASSERT_TRUE(argb8888_format == TBM_FORMAT_ARGB8888);
-
- surface = tbm_surface_internal_create_with_flags(720, 1024, argb8888_format, TBM_BO_DEFAULT);
- ASSERT_TRUE(surface != NULL);
-}
-
-void TBMSurfaceInternal::TearDown()
-{
- if (surface)
- tbm_surface_internal_destroy(surface);
-
- if (formats)
- free(formats);
-
- TBMBufmgr::TearDown();
-}
-
-/* tbm_surface_h tbm_surface_internal_create_with_flags(int width, int height, int format, int flags) */
-TEST_F(TBMSurfaceInternal, SurfaceInternalCeateDestroyTest)
-{
- tbm_surface_h surface1 = NULL;
-
- for (uint32_t i = 0; i < 1; i++) {
- surface1 = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
- EXPECT_NE(surface1, nullptr);
- 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));
- }
-}
-
-TEST_F(TBMSurfaceInternal, SurfaceInternalCeatewithParamsTest)
-{
- tbm_surface_h surface1 = NULL;
-
- surface1 = tbm_surface_internal_create_with_flags(-1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- 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);
- 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);
- 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));
- 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)
-{
- 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) */
-TEST_F(TBMSurfaceInternal, SurfaceInteranlIsValid)
-{
- tbm_surface_h invalid_surface;
-
- EXPECT_TRUE(tbm_surface_internal_is_valid(surface));
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- 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;
- 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);
- 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);
- 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);
- 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;
-
- /* invalid surface */
- bo = tbm_surface_internal_get_bo(invalide_surface, 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);
- EXPECT_EQ(nullptr, bo);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceInternal, GetBoSuccess)
-{
- tbm_bo bo = NULL;
- int num = 0;
-
- num = tbm_surface_internal_get_num_bos(surface);
- 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);
- EXPECT_NE(nullptr, bo);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
- }
-}
-
-/* tbm_surface_h tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, tbm_bo *bos, int num) */
-TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
- 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);
- 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);
- EXPECT_EQ(nullptr, surf);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
- EXPECT_STREQ(tbm_error_str(result), tbm_error_str(TBM_ERROR_NONE));
-
- num = tbm_surface_internal_get_num_bos(surface);
- EXPECT_GT(num, 0);
-
- for (int i = 0; i < num; i++) {
- bos[i] = tbm_surface_internal_get_bo(surface, 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);
- 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);
- 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);
- EXPECT_EQ(nullptr, surf);
- EXPECT_STRNE(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-TEST_F(TBMSurfaceInternal, 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_error_e)tbm_surface_get_info(surface, &info);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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));
-
- EXPECT_FALSE(tbm_surface_internal_is_valid(surface)) ;
-
- surface = NULL;
-}
-
-/* void tbm_surface_internal_ref(tbm_surface_h surface) */
-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);
- 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() */
-TEST_F(TBMSurfaceInternal, GetNumPlanes)
-{
- int num = 0;
- num = tbm_surface_internal_get_num_planes(0);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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)
-{
- 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;
-
- 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;
-
- 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));
-
- 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));
-
- 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) */
-TEST_F(TBMSurfaceInternal, GetBpp)
-{
- int bpp = 0;
- bpp = tbm_surface_internal_get_bpp(0);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- 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);
- EXPECT_EQ(0, idx);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceInternal, GetPlaneBoIndexFailInvaildInput)
-{
- int surf;
- int idx;
-
- idx = tbm_surface_internal_get_plane_bo_idx((tbm_surface_h)&surf, 0);
- 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);
- EXPECT_EQ(0, idx);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceInternal, GetPlaneBoIndexSuccess)
-{
- int idx;
-
- idx = tbm_surface_internal_get_plane_bo_idx(surface, 0);
- 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;
-void data_free_handle(void *user_data)
-{
- ASSERT_TRUE(user_data == &tbm_data_free_is_called);
- int *is_called = (int *)user_data;
- *is_called = 1;
-}
-
-/* tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key, tbm_data_free data_free_func) */
-TEST_F(TBMSurfaceInternal, AddUserDataFailNull)
-{
- static const unsigned long key_ud = 0;
- 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 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;
- 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;
- 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));
-
- 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;
- 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)
-{
- static const unsigned long key_ud = 0;
- int surf;
-
- 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;
- 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*/
- 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;
- 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;
- 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) */
-TEST_F(TBMSurfaceInternal, GetUserDataFailNull)
-{
- static const unsigned long key_ud = 0;
- int *data = NULL;
- 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));
-
- 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)
-{
- static const unsigned long key_ud = 0;
- int surf;
- int *data = NULL;
-
- 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)
-{
- unsigned long key_ud = 97456789;
- int *data = NULL;
-
- 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 */
- 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 */
- 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;
- 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;
- 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));
-
- 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;
-
- 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;
- 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
+++ /dev/null
-
-/**************************************************************************
- *
- * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
- *
- * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
- * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
- * Contact: Roman Marchenko <r.marchenko@samsung.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
-**************************************************************************/
-
-#include "ut_tbm.h"
-class TBMSurfaceQueue : public TBMBufmgr
-{
-protected:
- void SetUp();
- void TearDown();
-public:
- int width;
- int height;
- int format;
-
- uint32_t num_formats;
- tbm_format *formats;
-
- tbm_surface_h alien_surface;
- tbm_surface_queue_h queue;
-
- tbm_surface_queue_error_e result;
- tbm_surface_h surface;
-};
-
-void TBMSurfaceQueue::SetUp()
-{
- tbm_surface_error_e result = TBM_SURFACE_ERROR_NONE;
-
- TBMBufmgr::SetUp();
-
- result = (tbm_surface_error_e)tbm_surface_query_formats(&formats, &num_formats);
- EXPECT_STREQ(tbm_error_str(TBM_ERROR_NONE), tbm_error_str(result));
-
- for (uint32_t i = 0; i < num_formats; i++)
- if (formats[i] == TBM_FORMAT_ARGB8888)
- format = TBM_FORMAT_ARGB8888;
-
- /* fail if there is no TBM_FORMAT_ARGB8888 format */
- ASSERT_TRUE(format == TBM_FORMAT_ARGB8888);
-
- width = 720;
- height = 1024;
- alien_surface = tbm_surface_create(width, height, format);
- EXPECT_NE((tbm_surface_h)NULL, alien_surface);
-
- queue = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
- EXPECT_NE((tbm_surface_queue_h)NULL, queue);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-void TBMSurfaceQueue::TearDown()
-{
- if (alien_surface)
- tbm_surface_destroy(alien_surface);
-
- if (queue)
- tbm_surface_queue_destroy(queue);
-
- if (formats)
- free(formats);
-
- TBMBufmgr::TearDown();
-}
-
-static int memory_for_invalid_param;
-static tbm_surface_queue_h invalid_queue = (tbm_surface_queue_h)&memory_for_invalid_param;
-static tbm_surface_h invalid_surface = (tbm_surface_h)&memory_for_invalid_param;
-
-static int cb_data;
-static void tbm_surface_queue_event_handler(tbm_surface_queue_h surface_queue, void *data)
-{
- if (data == &cb_data)
- *((int *)data) = 1;
-}
-
-static tbm_surface_queue_trace trace_cb_data;
-static void tbm_surface_queue_trace_event_handler(tbm_surface_queue_h surface_queue,
- tbm_surface_h surface, tbm_surface_queue_trace trace, void *data)
-{
- if (data == &trace_cb_data)
- trace_cb_data = trace;
-}
-
-static tbm_surface_h tbm_surface_alloc_cb_handler(tbm_surface_queue_h surface_queue, void *data)
-{
- return (tbm_surface_h)data;
-}
-
-void tbm_surface_free_cb_handler(tbm_surface_queue_h surface_queue, void *data, tbm_surface_h surface)
-{
- if (data == surface)
- tbm_surface_destroy(surface);
-}
-
-TEST_F(TBMSurfaceQueue, CreateDestroyQueue)
-{
- tbm_surface_queue_h queue1 = NULL;
-
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, format, TBM_BO_DEFAULT);
- EXPECT_NE(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_surface_queue_destroy(queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-/* tbm_surface_queue_h tbm_surface_queue_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
- int height, int format, int flags); */
-TEST_F(TBMSurfaceQueue, CreateFailInvalidInput)
-{
- tbm_surface_queue_h queue1 = NULL;
-
- queue1 = tbm_surface_queue_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-/* tbm_surface_queue_h tbm_surface_queue_sequence_create(int UT_TBM_SURFACE_QUEUE_SIZE, int width,
- int height, int format, int flags); */
-TEST_F(TBMSurfaceQueue, SequenceCreateFailInvalidInput)
-{
- tbm_surface_queue_h queue1 = NULL;
-
- queue1 = tbm_surface_queue_sequence_create(-1, 720, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1); // Expected Value: NULL
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, -1, 1024, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, -1, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, 0, TBM_BO_DEFAULT);
- EXPECT_EQ(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, CreateDestroySequenceQueue)
-{
- tbm_surface_queue_h queue1 = NULL;
-
- queue1 = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, 720, 1024, formats[0], TBM_BO_DEFAULT);
- EXPECT_NE(nullptr, queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_surface_queue_destroy(queue1);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-
-/* void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, DestroyNULL)
-{
- tbm_surface_queue_destroy(NULL);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, DestroyTwice)
-{
- tbm_surface_queue_destroy(queue);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-
- tbm_surface_queue_destroy(queue);
- EXPECT_STREQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-
- /* to prevent destroy in TearDown */
- queue = NULL;
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_dequeue(
- tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
-TEST_F(TBMSurfaceQueue, DequeueFailNull)
-{
- ASSERT_EXIT({
- result = tbm_surface_queue_dequeue(NULL, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_dequeue(queue, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- exit(0);
- }, ::testing::ExitedWithCode(0), "");
-}
-
-TEST_F(TBMSurfaceQueue, DequeueFailInvaildInput)
-{
- result = tbm_surface_queue_dequeue(invalid_queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, DequeueSuccess)
-{
- /* do dequeue three times */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_NE((tbm_surface_h)NULL, surface);
- }
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(nullptr, surface);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_get_surfaces( tbm_surface_queue_h surface_queue,
- tbm_surface_h *surfaces, int *num); */
-TEST_F(TBMSurfaceQueue, GetSurfacesFailNull)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
- int num;
-
- result = tbm_surface_queue_get_surfaces(NULL, surfaces, &num);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_get_surfaces(queue, surfaces, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, GetSurfacesFailInvaildInput)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
- int num;
-
- result = tbm_surface_queue_get_surfaces(invalid_queue, surfaces, &num);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, GetSurfacesSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
- int num = 0;
-
- /* test: empty queue*/
- result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(0, num);
-
- /* do dequeue three times */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_NE(nullptr, surface);
- }
-
- /* test */
- result = tbm_surface_queue_get_surfaces(queue, surfaces, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
- EXPECT_NE(nullptr, surfaces[i]);
-
- /* test: get only number of surfaces */
- result = tbm_surface_queue_get_surfaces(queue, NULL, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, num);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
- tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
-TEST_F(TBMSurfaceQueue, CancelDequeueFailNull)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_dequeue(NULL, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_dequeue(queue, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, CancelDequeueFailInvaildInput)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
-
- result = tbm_surface_queue_cancel_dequeue(invalid_queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_dequeue(queue, invalid_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_dequeue(queue, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, CancelDequeueSuccess)
-{
- tbm_surface_h last_surface = NULL;
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_NE(nullptr, surface);
- }
-
- last_surface = surface;
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(nullptr, surface);
-
- /* test */
- result = tbm_surface_queue_cancel_dequeue(queue, last_surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(last_surface, surface);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_enqueue(
- tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
-TEST_F(TBMSurfaceQueue, EnqueueFailNull)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_enqueue(NULL, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_enqueue(this->queue, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, EnqueueFailInvaildInput)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_enqueue(invalid_queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_enqueue(queue, invalid_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_enqueue(queue, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, EnqueueSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
-
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_enqueue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-}
-
-TEST_F(TBMSurfaceQueue, EnqueueFailTwice)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_acquire(
- tbm_surface_queue_h surface_queue, tbm_surface_h *surface); */
-TEST_F(TBMSurfaceQueue, AcquireFailNull)
-{
- /* test */
- result = tbm_surface_queue_acquire(NULL, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AcquireFailInvaildInput)
-{
- result = tbm_surface_queue_acquire(invalid_queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AcquireFailAcquireEmptyQueue)
-{
- result = tbm_surface_queue_acquire(invalid_queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AcquireSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
- tbm_surface_h acquired_surface = NULL;
-
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_acquire(queue, &acquired_surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(surfaces[i], acquired_surface);
- }
-
- /* test: acquire empty queue*/
- result = tbm_surface_queue_acquire(queue, &acquired_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(nullptr, acquired_surface);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
- tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
-TEST_F(TBMSurfaceQueue, CancelAcquireFailNull)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
-
- /* test */
- result = tbm_surface_queue_cancel_acquire(NULL, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_acquire(queue, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, CancelAcquireFailInvaildInput)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_cancel_acquire(invalid_queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_acquire(queue, invalid_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_cancel_acquire(queue, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, CancelAcquireSuccess)
-{
- tbm_surface_h last_surface = NULL;
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- last_surface = surface;
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(nullptr, surface);
-
- /* test */
- result = tbm_surface_queue_cancel_acquire(queue, last_surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(last_surface, surface);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_release(
- tbm_surface_queue_h surface_queue, tbm_surface_h surface); */
-TEST_F(TBMSurfaceQueue, ReleaseFailNull)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_release(NULL, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_release(this->queue, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, ReleaseFailInvaildInput)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_release(invalid_queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_release(queue, invalid_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_release(queue, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, ReleaseSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_release(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-}
-
-TEST_F(TBMSurfaceQueue, ReleaseSequenceSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE] = { NULL };
-
- /* create a sequence queue instead of a default one*/
- tbm_surface_queue_destroy(queue);
- queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_release(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-}
-
-TEST_F(TBMSurfaceQueue, ReleaseFailTwice)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_release(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_release(queue, surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-/* int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, GetWidthFailNull)
-{
- int width = tbm_surface_queue_get_width(NULL);
- EXPECT_EQ(0, width);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetWidthFailInvalidInput)
-{
- int width = tbm_surface_queue_get_width(invalid_queue);
- EXPECT_EQ(0, width);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetWidthSuccess)
-{
- int width = tbm_surface_queue_get_width(queue);
- EXPECT_EQ(this->width, width);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-/* int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, GetHeightFailNull)
-{
- int height = tbm_surface_queue_get_height(NULL);
- EXPECT_EQ(0, height);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetHeightFailInvalidInput)
-{
- int height = tbm_surface_queue_get_height(invalid_queue);
- EXPECT_EQ(0, height);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetHeightSuccess)
-{
- int height = tbm_surface_queue_get_height(queue);
- EXPECT_EQ(this->height, height);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-/* int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, GetFormatFailNull)
-{
- int format = tbm_surface_queue_get_format(NULL);
- EXPECT_EQ(0, format);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetFormatFailInvalidInput)
-{
- int format = tbm_surface_queue_get_format(invalid_queue);
- EXPECT_EQ(0, format);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetFormatSuccess)
-{
- int format = tbm_surface_queue_get_format(queue);
- EXPECT_EQ((int)this->format, format);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-/* int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, GetSizeFailNull)
-{
- int q_size = tbm_surface_queue_get_size(NULL);
- EXPECT_EQ(0, q_size);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetSizeFailInvalidInput)
-{
- int q_size = tbm_surface_queue_get_size(invalid_queue);
- EXPECT_EQ(0, q_size);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_INVALID_PARAMETER));
-}
-
-TEST_F(TBMSurfaceQueue, GetSizeSuccess)
-{
- int q_size = tbm_surface_queue_get_size(queue);
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, q_size);
- EXPECT_EQ(tbm_error_str(tbm_get_last_error()), tbm_error_str(TBM_ERROR_NONE));
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_reset(
- tbm_surface_queue_h surface_queue, int width, int height, int format); */
-TEST_F(TBMSurfaceQueue, ResetFailNull)
-{
- result = tbm_surface_queue_reset(NULL, width, height, format);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, ResetFailInvalidInput)
-{
- result = tbm_surface_queue_reset(invalid_queue, width, height, format);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_reset(invalid_queue, -1, height, format);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_reset(invalid_queue, width, -1, format);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_reset(invalid_queue, width, height, 0);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, ResetSuccessEmptyQueue)
-{
- result = tbm_surface_queue_reset(queue, width-10, height-10, format);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, ResetSuccessSameParams)
-{
- tbm_surface_h surface = NULL;
-
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_reset(queue, width, height, format);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
-}
-
-TEST_F(TBMSurfaceQueue, ResetSuccess)
-{
- tbm_surface_h surface = NULL;
-
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
-}
-
-TEST_F(TBMSurfaceQueue, ResetSequenceSuccess)
-{
- tbm_surface_h surface = NULL;
-
- /* create a sequence queue instead of a default one*/
- tbm_surface_queue_destroy(queue);
- queue = tbm_surface_queue_sequence_create(UT_TBM_SURFACE_QUEUE_SIZE, width, height, format, TBM_BO_DEFAULT);
- ASSERT_TRUE(queue != NULL);
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_reset(queue, width-10, height-10, formats[num_formats-1]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_set_size(
- tbm_surface_queue_h surface_queue, int UT_TBM_SURFACE_QUEUE_SIZE, int flush); */
-TEST_F(TBMSurfaceQueue, SetSizeFailNull)
-{
- result = tbm_surface_queue_set_size(NULL, UT_TBM_SURFACE_QUEUE_SIZE, 0);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetSizeFailInvalidInput)
-{
- result = tbm_surface_queue_set_size(invalid_queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_set_size(NULL, 0, 0);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetSizeSuccessTheSameSize)
-{
- tbm_surface_h surface = NULL;
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 0);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
-
- /*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE, 1);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
-}
-
-TEST_F(TBMSurfaceQueue, SetSizeSuccessIncrease)
-{
- tbm_surface_h surface = NULL;
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+1, 0);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
-
- /*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE+2, 1);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
-}
-
-TEST_F(TBMSurfaceQueue, SetSizeSuccessReduce)
-{
- tbm_surface_h surface = NULL;
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*test: */
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-1, 0);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(tbm_surface_internal_is_valid(surface)) << "old surface mast be valid";
-
- /*test: with flush*/
- result = tbm_surface_queue_set_size(queue, UT_TBM_SURFACE_QUEUE_SIZE-2, 1);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_FALSE(tbm_surface_internal_is_valid(surface)) << "old surface has to be deleted";
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, FlushFailNull)
-{
- result = tbm_surface_queue_flush(NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, FlushFailInvalidInput)
-{
- result = tbm_surface_queue_flush(invalid_queue);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, FlushSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
-
- /*test: flushing not initialized queue*/
- result = tbm_surface_queue_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
-
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- result = tbm_surface_queue_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
- ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, FreeFlushFailNull)
-{
- result = tbm_surface_queue_free_flush(NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, FreeFlushFailInvalidInput)
-{
- result = tbm_surface_queue_free_flush(invalid_queue);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, FreeFlushSuccess)
-{
- tbm_surface_h surfaces[UT_TBM_SURFACE_QUEUE_SIZE];
-
- /*test: flushing not initialized queue*/
- result = tbm_surface_queue_free_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
-
- /* init queue */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++) {
- result = tbm_surface_queue_dequeue(queue, &surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_cancel_dequeue(queue, surfaces[i]);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- result = tbm_surface_queue_free_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* extra check */
- for (int i = 0; i < UT_TBM_SURFACE_QUEUE_SIZE; i++)
- ASSERT_FALSE(tbm_surface_internal_is_valid(surfaces[i])) << "old surface has to be deleted";
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddResetCbFailNull)
-{
- result = tbm_surface_queue_add_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_reset_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddResetCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddResetCbSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*extra check: reset cb has to called after tbm_surface_queue_flush()*/
- cb_data = 0;
- result = tbm_surface_queue_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveResetCbFailNull)
-{
- result = tbm_surface_queue_remove_reset_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveResetCbSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_enqueue(queue, surface);
- result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-
- /* test */
- result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*extra check: reset cb musn't called after tbm_surface_queue_flush()*/
- cb_data = 0;
- result = tbm_surface_queue_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 0);
-}
-
-TEST_F(TBMSurfaceQueue, RemoveResetCbFailInvalidInput)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_enqueue(queue, surface);
- result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
-
- /* test: invalid queue*/
- result = tbm_surface_queue_remove_reset_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test: invalid data */
- result = tbm_surface_queue_remove_reset_cb(queue, tbm_surface_queue_event_handler, NULL);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test: invalid cb function */
- result = tbm_surface_queue_remove_reset_cb(queue, (tbm_surface_queue_notify_cb)1, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /*extra check: reset cb still has to be called after tbm_surface_queue_flush()*/
- cb_data = 0;
- result = tbm_surface_queue_flush(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, NotifyResetFailNull)
-{
- result = tbm_surface_queue_notify_reset(NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, NotifyResetFailInvalidInput)
-{
- result = tbm_surface_queue_notify_reset(invalid_queue);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, NotifyResetCbSuccess)
-{
- result = tbm_surface_queue_add_reset_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- cb_data = 0;
- result = tbm_surface_queue_notify_reset(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue); */
-TEST_F(TBMSurfaceQueue, NotifyDequeuableFailNull)
-{
- result = tbm_surface_queue_notify_dequeuable(NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, NotifyDequeuableFailInvalidInput)
-{
- result = tbm_surface_queue_notify_dequeuable(invalid_queue);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, NotifyDequeuableCbSuccess)
-{
- /* test */
- result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_notify_dequeuable(queue);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait); */
-TEST_F(TBMSurfaceQueue, CanDequeueFailNull)
-{
- ASSERT_FALSE(tbm_surface_queue_can_dequeue(NULL, 0));
-}
-
-TEST_F(TBMSurfaceQueue, CanDequeueFailInvalidInput)
-{
- ASSERT_FALSE(tbm_surface_queue_can_dequeue(invalid_queue, 0));
-}
-
-TEST_F(TBMSurfaceQueue, CanDequeueSuccess)
-{
- int dq_count = 0;
-
- /* test: dequeue all*/
- while (tbm_surface_queue_can_dequeue(queue, 0)) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- dq_count++;
- }
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, dq_count);
-}
-
-TEST_F(TBMSurfaceQueue, CanDequeueFailEmptyQueue)
-{
- /*Dequeue all*/
- while (tbm_surface_queue_can_dequeue(queue, 0)) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- }
-
- /* test */
- ASSERT_FALSE(tbm_surface_queue_can_dequeue(queue, 0));
-}
-
-
-/* int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait); */
-TEST_F(TBMSurfaceQueue, CanAcquireFailNull)
-{
- ASSERT_FALSE(tbm_surface_queue_can_acquire(NULL, 0));
-}
-
-TEST_F(TBMSurfaceQueue, CanAcquireFailInvalidInput)
-{
- ASSERT_FALSE(tbm_surface_queue_can_acquire(invalid_queue, 0));
-}
-
-TEST_F(TBMSurfaceQueue, CanAcquireFailEmptyQueue)
-{
- ASSERT_FALSE(tbm_surface_queue_can_acquire(queue, 0));
-}
-
-TEST_F(TBMSurfaceQueue, CanAcquireSuccess)
-{
- int acq_count = 0;
-
- while (tbm_surface_queue_can_dequeue(queue, 0)) {
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- }
-
- /*Dequeue all*/
- while (tbm_surface_queue_can_acquire(queue, 0)) {
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- acq_count++;
- }
-
- EXPECT_EQ(UT_TBM_SURFACE_QUEUE_SIZE, acq_count);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddDestroyCbFailNull)
-{
- result = tbm_surface_queue_add_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_destroy_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDestroyCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDestroyCbSuccess)
-{
- /* test */
- result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- tbm_surface_queue_destroy(queue);
- ASSERT_TRUE(cb_data == 1);
-
- /* to avoid destroying queue in TearDown*/
- queue = NULL;
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailNull)
-{
- result = tbm_surface_queue_remove_destroy_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDestroyCbFailInvalidInput)
-{
- result = tbm_surface_queue_remove_destroy_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDestroyCbSuccess)
-{
- result = tbm_surface_queue_add_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_remove_destroy_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- tbm_surface_queue_destroy(queue);
- ASSERT_TRUE(cb_data == 0);
-
- /* to avoid destroying queue in TearDown*/
- queue = NULL;
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddDequeuableCbFailNull)
-{
- result = tbm_surface_queue_add_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_dequeuable_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDequeuableCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDequeuableCbSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_release(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailNull)
-{
- result = tbm_surface_queue_remove_dequeuable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDequeuableCbFailInvalidInput)
-{
- /* test: invalid queue */
- result = tbm_surface_queue_remove_dequeuable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDequeuableCbSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_add_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_remove_dequeuable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_release(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 0);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddDequeueCbFailNull)
-{
- result = tbm_surface_queue_add_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_dequeue_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDequeueCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddDequeueCbSuccess)
-{
- /* test */
- result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailNull)
-{
- result = tbm_surface_queue_remove_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDequeueCbFailInvalidInput)
-{
- /* test: invalid queue */
- result = tbm_surface_queue_remove_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveDequeueCbSuccess)
-{
- /* test */
- result = tbm_surface_queue_add_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-
- result = tbm_surface_queue_remove_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 0);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailNull)
-{
- result = tbm_surface_queue_add_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_can_dequeue_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddCanDequeueCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddCanDequeueCbSuccess)
-{
- /* test */
- result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailNull)
-{
- result = tbm_surface_queue_remove_can_dequeue_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbFailInvalidInput)
-{
- /* test: invalid queue */
- result = tbm_surface_queue_remove_can_dequeue_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveCanDequeueCbSuccess)
-{
- result = tbm_surface_queue_add_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_remove_can_dequeue_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- ASSERT_TRUE(tbm_surface_queue_can_dequeue(queue, 0));
- ASSERT_TRUE(cb_data == 0);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddAcquirableCbFailNull)
-{
- result = tbm_surface_queue_add_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_acquirable_cb(queue, NULL, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddAcquirableCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddAcquirableCbSuccess)
-{
- tbm_surface_queue_dequeue(queue, &surface);
-
- /* test */
- result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 1);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailNull)
-{
- result = tbm_surface_queue_remove_acquirable_cb(NULL, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveAcquirableCbFailInvalidInput)
-{
- /* test: invalid queue */
- result = tbm_surface_queue_remove_acquirable_cb(invalid_queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveAcquirableCbSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- result = tbm_surface_queue_add_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_remove_acquirable_cb(queue, tbm_surface_queue_event_handler, &cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- cb_data = 0;
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(cb_data == 0);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
-TEST_F(TBMSurfaceQueue, AddTraceCbFailNull)
-{
- result = tbm_surface_queue_add_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_add_trace_cb(queue, NULL, &trace_cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddTraceCbFailInvalidInput)
-{
- result = tbm_surface_queue_add_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, AddTraceCbSuccess)
-{
- trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
-
- /* test */
- result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_DEQUEUE);
-
- result = tbm_surface_queue_cancel_dequeue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE);
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ENQUEUE);
-
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_ACQUIRE);
-
- result = tbm_surface_queue_cancel_acquire(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE);
-
- result = tbm_surface_queue_acquire(queue, &surface);
- result = tbm_surface_queue_release(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_RELEASE);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb, void *data); */
-TEST_F(TBMSurfaceQueue, RemoveTraceCbFailNull)
-{
- result = tbm_surface_queue_remove_trace_cb(NULL, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveTraceCbFailInvalidInput)
-{
- /* test: invalid queue */
- result = tbm_surface_queue_remove_trace_cb(invalid_queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, RemoveTraceCbSuccess)
-{
- trace_cb_data = TBM_SURFACE_QUEUE_TRACE_NONE;
-
- result = tbm_surface_queue_add_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test */
- result = tbm_surface_queue_remove_trace_cb(queue, tbm_surface_queue_trace_event_handler, &trace_cb_data);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- ASSERT_TRUE(trace_cb_data == TBM_SURFACE_QUEUE_TRACE_NONE);
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb( tbm_surface_queue_h surface_queue,
- tbm_surface_alloc_cb alloc_cb, tbm_surface_free_cb free_cb, void *data); */
-TEST_F(TBMSurfaceQueue, SetAllocCbFailNull)
-{
- result = tbm_surface_queue_set_alloc_cb(NULL, tbm_surface_alloc_cb_handler,
- tbm_surface_free_cb_handler, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetAllocCbFailInvalidInput)
-{
- result = tbm_surface_queue_set_alloc_cb(invalid_queue, tbm_surface_alloc_cb_handler,
- tbm_surface_free_cb_handler, alien_surface);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetAllocCbSuccess)
-{
- result = tbm_surface_queue_set_alloc_cb(queue, tbm_surface_alloc_cb_handler,
- tbm_surface_free_cb_handler, alien_surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test: allocate */
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(alien_surface, surface);
-
- /* test: alien_surface has to be deleted*/
- tbm_surface_queue_destroy(queue);
- ASSERT_FALSE(tbm_surface_internal_is_valid(alien_surface));
-
- alien_surface = NULL;
-}
-
-/* tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num(
- tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num); */
-TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailNull)
-{
- int num = 0;
-
- ASSERT_EXIT({
-
- result = tbm_surface_queue_get_trace_surface_num(NULL, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, NULL);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- exit(0);
- }, ::testing::ExitedWithCode(0), "");
-
-}
-
-TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumFailInvalidInput)
-{
- int num = 0;
-
- result = tbm_surface_queue_get_trace_surface_num(invalid_queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, GetTraceSurfaceNumSuccess)
-{
- int num = 0;
-
- result = tbm_surface_queue_set_size(queue, 4, 0);
-
- /* one acquired */
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_enqueue(queue, surface);
- result = tbm_surface_queue_acquire(queue, &surface);
-
- /* one enqueued */
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_enqueue(queue, surface);
-
- /* one dequeued */
- result = tbm_surface_queue_dequeue(queue, &surface);
-
- /* one released */
- result = tbm_surface_queue_dequeue(queue, &surface);
- result = tbm_surface_queue_cancel_dequeue(queue, surface);
-
-
- /* test */
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_NONE, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(0, num);
-
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(1, num);
-
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ENQUEUE, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(1, num);
-
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_ACQUIRE, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(1, num);
-
- result = tbm_surface_queue_get_trace_surface_num(queue, TBM_SURFACE_QUEUE_TRACE_RELEASE, &num);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
- EXPECT_EQ(1, num);
-}
-/* tbm_surface_queue_error_e tbm_surface_queue_set_modes(
- tbm_surface_queue_h surface_queue, int modes); */
-TEST_F(TBMSurfaceQueue, SetModesFailNull)
-{
- result = tbm_surface_queue_set_modes(NULL, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetModesFailInvalidInput)
-{
- result = tbm_surface_queue_set_modes(invalid_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetModesSuccess)
-{
- result = tbm_surface_queue_set_modes(queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-/* tbm_surface_queue_set_sync_count() */
-TEST_F(TBMSurfaceQueue, SetSyncCountFailNull)
-{
- result = tbm_surface_queue_set_sync_count(NULL, 1);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetSyncCountFailInvalidInput)
-{
- result = tbm_surface_queue_set_sync_count(invalid_queue, 1);
- EXPECT_NE(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
-
-TEST_F(TBMSurfaceQueue, SetSyncCountSuccess)
-{
- result = tbm_surface_queue_dequeue(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test: map after enqueue */
- result = tbm_surface_queue_set_sync_count(queue, 0);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_enqueue(queue, surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- /* test: map after acquire */
- result = tbm_surface_queue_set_sync_count(queue, 0);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-
- result = tbm_surface_queue_acquire(queue, &surface);
- EXPECT_EQ(tbm_error_str(TBM_SURFACE_QUEUE_ERROR_NONE), tbm_error_str(result));
-}
\ No newline at end of file
projects / platform / core / uifw / libtbm.git / commitdiff