From: SooChan Lim <sc1.lim@samsung.com>
Date: Fri, 4 May 2018 02:42:28 +0000 (+0900)
Subject: change the utests to haltests
X-Git-Tag: submit/tizen/20180504.060653~1
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a2f154a5f591caf2bb5f2afb8584db4f203ed6da;p=platform%2Fcore%2Fuifw%2Flibtbm.git

change the utests to haltests

change all symbol and file name.

Change-Id: Ia4cfcbbcb41ead714f8fa7a0a00d42a54a1cb528
---

diff --git a/Makefile.am b/Makefile.am
index f058365..d8b525d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@
-if HAVE_UTEST
-SUBDIRS = src utests
+if HAVE_HALTESTS
+SUBDIRS = src haltests
 else
 SUBDIRS = src
 endif
diff --git a/configure.ac b/configure.ac
index 88a4960..fc14ad5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -51,11 +51,11 @@ AC_ARG_WITH(bufmgr-module-path, AS_HELP_STRING([--with-bufmgr-module-path=PATH],
 				[ 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])
@@ -112,7 +112,7 @@ AC_OUTPUT([
    src/Makefile
 	Makefile
 	libtbm.pc
-	utests/Makefile])
+	haltests/Makefile])
 
 echo ""
 echo "CFLAGS            : $CFLAGS"
diff --git a/haltests/Makefile.am b/haltests/Makefile.am
new file mode 100644
index 0000000..08f21a8
--- /dev/null
+++ b/haltests/Makefile.am
@@ -0,0 +1,28 @@
+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
diff --git a/haltests/tc_main.cpp b/haltests/tc_main.cpp
new file mode 100644
index 0000000..a936217
--- /dev/null
+++ b/haltests/tc_main.cpp
@@ -0,0 +1,66 @@
+/**************************************************************************
+ *
+ * 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;
+}
diff --git a/haltests/tc_tbm.h b/haltests/tc_tbm.h
new file mode 100644
index 0000000..7393f8d
--- /dev/null
+++ b/haltests/tc_tbm.h
@@ -0,0 +1,111 @@
+/**************************************************************************
+ *
+ * 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
diff --git a/haltests/tc_tbm_backend.cpp b/haltests/tc_tbm_backend.cpp
new file mode 100644
index 0000000..8e7340f
--- /dev/null
+++ b/haltests/tc_tbm_backend.cpp
@@ -0,0 +1,348 @@
+/**************************************************************************
+ *
+ * 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);
+}
+
+
+
diff --git a/haltests/tc_tbm_bo.cpp b/haltests/tc_tbm_bo.cpp
new file mode 100644
index 0000000..2e938da
--- /dev/null
+++ b/haltests/tc_tbm_bo.cpp
@@ -0,0 +1,1251 @@
+
+/**************************************************************************
+ *
+ * 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")));
diff --git a/haltests/tc_tbm_bufmgr.cpp b/haltests/tc_tbm_bufmgr.cpp
new file mode 100644
index 0000000..19ea7b5
--- /dev/null
+++ b/haltests/tc_tbm_bufmgr.cpp
@@ -0,0 +1,159 @@
+/**************************************************************************
+ *
+ * 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")));
+
diff --git a/haltests/tc_tbm_env.cpp b/haltests/tc_tbm_env.cpp
new file mode 100644
index 0000000..024ae72
--- /dev/null
+++ b/haltests/tc_tbm_env.cpp
@@ -0,0 +1,226 @@
+/**************************************************************************
+ *
+ * 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
diff --git a/haltests/tc_tbm_log.cpp b/haltests/tc_tbm_log.cpp
new file mode 100644
index 0000000..684fda2
--- /dev/null
+++ b/haltests/tc_tbm_log.cpp
@@ -0,0 +1,105 @@
+
+/**************************************************************************
+ *
+ * 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
diff --git a/haltests/tc_tbm_surface.cpp b/haltests/tc_tbm_surface.cpp
new file mode 100644
index 0000000..6c75858
--- /dev/null
+++ b/haltests/tc_tbm_surface.cpp
@@ -0,0 +1,308 @@
+/**************************************************************************
+ *
+ * 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));
+}
+
diff --git a/haltests/tc_tbm_surface_internal.cpp b/haltests/tc_tbm_surface_internal.cpp
new file mode 100644
index 0000000..a3a27ec
--- /dev/null
+++ b/haltests/tc_tbm_surface_internal.cpp
@@ -0,0 +1,686 @@
+/**************************************************************************
+ *
+ * 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
diff --git a/haltests/tc_tbm_surface_queue.cpp b/haltests/tc_tbm_surface_queue.cpp
new file mode 100644
index 0000000..782f15a
--- /dev/null
+++ b/haltests/tc_tbm_surface_queue.cpp
@@ -0,0 +1,1714 @@
+
+/**************************************************************************
+ *
+ * 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
diff --git a/packaging/libtbm.spec b/packaging/libtbm.spec
index 5be680c..2a09e1b 100644
--- a/packaging/libtbm.spec
+++ b/packaging/libtbm.spec
@@ -1,7 +1,7 @@
 %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
@@ -19,7 +19,7 @@ BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(libpng)
 BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(pixman-1)
-BuildRequires:  gtest-devel 
+BuildRequires:  gtest-devel
 
 %description
 Description: %{summary}
@@ -35,7 +35,7 @@ The library for Tizen Buffer Manager.
 
 Development Files.
 
-%if "%{UTEST_PACKAGE}" == "1"
+%if "%{HALTESTS_PACKAGE}" == "1"
 %package haltests
 Summary: Tizen Buffer Manager unit tests package
 Group: System/Libraries
@@ -51,23 +51,23 @@ Test module for testing libtbm APIs
 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
 
@@ -120,8 +120,8 @@ rm -f %{_unitdir_user}/basic.target.wants/tbm-drm-auth-user.path
 %{_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
diff --git a/utests/Makefile.am b/utests/Makefile.am
deleted file mode 100644
index 8da2182..0000000
--- a/utests/Makefile.am
+++ /dev/null
@@ -1,28 +0,0 @@
-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
diff --git a/utests/ut_main.cpp b/utests/ut_main.cpp
deleted file mode 100644
index a936217..0000000
--- a/utests/ut_main.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/**************************************************************************
- *
- * 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;
-}
diff --git a/utests/ut_tbm.h b/utests/ut_tbm.h
deleted file mode 100644
index 7393f8d..0000000
--- a/utests/ut_tbm.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/**************************************************************************
- *
- * 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
diff --git a/utests/ut_tbm_backend.cpp b/utests/ut_tbm_backend.cpp
deleted file mode 100644
index 2bb6fd7..0000000
--- a/utests/ut_tbm_backend.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-/**************************************************************************
- *
- * 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);
-}
-
-
-
diff --git a/utests/ut_tbm_bo.cpp b/utests/ut_tbm_bo.cpp
deleted file mode 100644
index 5cdf951..0000000
--- a/utests/ut_tbm_bo.cpp
+++ /dev/null
@@ -1,1251 +0,0 @@
-
-/**************************************************************************
- *
- * 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")));
diff --git a/utests/ut_tbm_bufmgr.cpp b/utests/ut_tbm_bufmgr.cpp
deleted file mode 100644
index c065415..0000000
--- a/utests/ut_tbm_bufmgr.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-/**************************************************************************
- *
- * 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")));
-
diff --git a/utests/ut_tbm_env.cpp b/utests/ut_tbm_env.cpp
deleted file mode 100644
index 4d41cb8..0000000
--- a/utests/ut_tbm_env.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-/**************************************************************************
- *
- * 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
diff --git a/utests/ut_tbm_log.cpp b/utests/ut_tbm_log.cpp
deleted file mode 100644
index 3bc2227..0000000
--- a/utests/ut_tbm_log.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-
-/**************************************************************************
- *
- * 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
diff --git a/utests/ut_tbm_surface.cpp b/utests/ut_tbm_surface.cpp
deleted file mode 100644
index 9ea2a31..0000000
--- a/utests/ut_tbm_surface.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-/**************************************************************************
- *
- * 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));
-}
-
diff --git a/utests/ut_tbm_surface_internal.cpp b/utests/ut_tbm_surface_internal.cpp
deleted file mode 100644
index da12fe5..0000000
--- a/utests/ut_tbm_surface_internal.cpp
+++ /dev/null
@@ -1,686 +0,0 @@
-/**************************************************************************
- *
- * 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
diff --git a/utests/ut_tbm_surface_queue.cpp b/utests/ut_tbm_surface_queue.cpp
deleted file mode 100644
index 0a664cd..0000000
--- a/utests/ut_tbm_surface_queue.cpp
+++ /dev/null
@@ -1,1714 +0,0 @@
-
-/**************************************************************************
- *
- * 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