test: Add efl-util test case

Make efl-util APIs gtest.
Transform pubilc API testcases from public gerrit test/tct/native/api.
Transform internal API testcases from spin gerrit test/testsuite/platform.

Usage : efl-util-tests

Change-Id: I4db9db0ad0c0204563e2003d8f2b70d96d0e7dba
Signed-off-by: Junkyeong Kim <jk0430.kim@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8cb32e0..7779b9c 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,6 +69,8 @@ CONFIGURE_FILE(
 )
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 
+ADD_SUBDIRECTORY(test)
+
 IF(UNIX)
 
 ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)

diff --git a/packaging/capi-ui-efl-util.spec b/packaging/capi-ui-efl-util.spec
index 96b5d93..b1116f3 100644 (file)
--- a/packaging/capi-ui-efl-util.spec
+++ b/packaging/capi-ui-efl-util.spec
@@ -19,6 +19,7 @@ BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(capi-system-info)
 BuildRequires:  pkgconfig(libdrm)
 BuildRequires:  pkgconfig(libtbm)
+BuildRequires:  gtest-devel
 
 %{!?TZ_SYS_RO_SHARE: %global TZ_SYS_RO_SHARE /usr/share}
 
@@ -33,6 +34,13 @@ Requires: %{name} = %{version}-%{release}
 %description devel
 %devel_desc
 
+%package -n efl-util-tests
+Summary: Tizen EFL utility library unit tests package
+Group: Development/Libraries
+
+%description -n efl-util-tests
+Test module for testing efl-util APIs
+
 %if 0%{?gcov:1}
 %package -n capi-ui-efl-util-gcov
 Summary: efl-util gcov data package
@@ -85,6 +93,10 @@ find . -name '*.gcno' -exec cp --parents '{}' "$gcno_obj_dir" ';'
 %{_libdir}/libcapi-ui-efl-util.so
 %exclude %{_includedir}/ui/config.h
 
+%files -n efl-util-tests
+%defattr(-,root,root,-)
+%{_bindir}/efl-util-tests
+
 %if 0%{?gcov:1}
 %files -n capi-ui-efl-util-gcov
 %{_datadir}/gcov/obj/*

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644 (file)
index 0000000..118198b
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,38 @@
+SET(EXEC_NAME "efl-util-tests")
+
+SET(TC_SOURCES
+    efl-util-tests.cpp
+    tc-efl-util.cpp
+    tc-efl-util-internal.cpp
+)
+
+PKG_CHECK_MODULES(REQUIRED_PKGS REQUIRED
+    glib-2.0
+    dlog
+    elementary
+    ecore-wl2
+    capi-base-common
+    capi-system-info
+    libdrm
+    libtbm
+    wayland-client
+    wayland-tbm-client
+    screenshooter-client
+    tizen-extension-client
+    gtest
+    gmock
+)
+
+INCLUDE_DIRECTORIES(
+    ${INC_DIR}
+    ${GTEST_INCLUDE_DIR}
+)
+
+SET(CMAKE_CXX_FLAGS "${CXXFLAGS} ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -O2 -g -fPIE -Wall -Werror -lgtest")
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}")
+ADD_EXECUTABLE(${EXEC_NAME} ${TC_SOURCES})
+TARGET_LINK_LIBRARIES(${EXEC_NAME}
+       ${REQUIRED_PKGS_LDFLAGS}
+       ${fw_name}
+)
+INSTALL(TARGETS ${EXEC_NAME} DESTINATION ${BIN_DIR})

diff --git a/test/efl-util-tests.cpp b/test/efl-util-tests.cpp
new file mode 100644 (file)
index 0000000..7545995
--- /dev/null
+++ b/test/efl-util-tests.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 "gmock/gmock.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::InitGoogleMock(&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/test/tc-efl-util-internal.cpp b/test/tc-efl-util-internal.cpp
new file mode 100644 (file)
index 0000000..a43d6b6
--- /dev/null
+++ b/test/tc-efl-util-internal.cpp
@@ -0,0 +1,708 @@
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tc-efl-util.h"
+
+EFLUtilInternal::EFLUtilInternal()
+{
+}
+
+void EFLUtilInternal::SetUp(void)
+{
+}
+
+void EFLUtilInternal::TearDown(void)
+{
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD | EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_NONE);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_with_name_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD | EFL_UTIL_INPUT_DEVTYPE_POINTER, "tc_device");
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_with_name_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_NONE, "tc_device");
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_with_sync_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD | EFL_UTIL_INPUT_DEVTYPE_POINTER, NULL);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_with_sync_p2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD | EFL_UTIL_INPUT_DEVTYPE_POINTER, "tc_device");
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_initialize_generator_with_sync_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_NONE, "tc_device");
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+}
+
+TEST_F(EFLUtilInternal, input_deinitialize_generator_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD | EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_deinitialize_generator_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_key_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_key(inputgen, "XF86Back", 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_key(inputgen, "XF86Back", 0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_key_p2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_key(inputgen, "Keycode-169", 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_key(inputgen, "Keycode-169", 0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_key_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_key(inputgen, "None", 1);
+   if (ret == EFL_UTIL_ERROR_NONE)
+     ret = efl_util_input_generate_key(inputgen, "None", 0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_key_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_generate_key(inputgen, "None", 1);
+   if (ret == EFL_UTIL_ERROR_NONE)
+     ret = efl_util_input_generate_key(inputgen, "None", 0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_UPDATE, 110, 160);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_END, 110, 160);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_NONE, -1, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_END, -1, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_NONE, -1, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_generate_touch(inputgen, 0, EFL_UTIL_INPUT_TOUCH_END, -1, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_pointer_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_BUTTON_DOWN, 100, 150);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_MOVE, 110, 160);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_BUTTON_UP, 110, 160);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_pointer_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_BUTTON_DOWN, 100, 150);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_pointer_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_pointer(inputgen, -1, EFL_UTIL_INPUT_POINTER_BUTTON_DOWN, 100, 150);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_pointer_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_BUTTON_DOWN, -1, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_pointer_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_pointer(inputgen, 1, EFL_UTIL_INPUT_POINTER_BUTTON_DOWN, 100, 150);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_wheel_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_wheel(inputgen, EFL_UTIL_INPUT_POINTER_WHEEL_VERT, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_wheel(inputgen, EFL_UTIL_INPUT_POINTER_WHEEL_HORZ, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_wheel_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_generate_wheel(inputgen, EFL_UTIL_INPUT_POINTER_WHEEL_VERT, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_wheel_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_wheel(inputgen, EFL_UTIL_INPUT_POINTER_WHEEL_VERT, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_wheel_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_POINTER);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_wheel(inputgen, (efl_util_input_pointer_wheel_type_e)-1, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150, 4.0, 4.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_UPDATE, 110, 160, 4.0, 4.0, 3.0, 1.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_END, 110, 160, 4.0, 4.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_NONE, -1, -1, 0.0, 0.0, 0.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, -1, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150, 4.0, 4.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, -1, -1, 4.0, 4.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150, 4.0, 4.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n5)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150, -1.0, -1.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n6)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_BEGIN, 100, 150, 4.0, 2.0, -1.0, 0.0, -1.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, input_generate_touch_axis_n7)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_inputgen_h inputgen = NULL;
+
+   inputgen = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(inputgen, nullptr);
+
+   ret = efl_util_input_generate_touch_axis(inputgen, 0, EFL_UTIL_INPUT_TOUCH_NONE, 100, 150, 4.0, 2.0, 2.0, 0.0, 0.0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_input_deinitialize_generator(inputgen);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_initialize_p)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_initialize_n)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(0, 0);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+   EXPECT_EQ(screenshot, nullptr);
+}
+
+TEST_F(EFLUtilInternal, screenshot_deinitialize_p)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_deinitialize_n)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, screenshot_take_tbm_surface_p)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   tbm_surface_h tbm_surface = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   tbm_surface = efl_util_screenshot_take_tbm_surface(screenshot);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(tbm_surface, nullptr);
+
+   tbm_surface_destroy(tbm_surface);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_take_tbm_surface_n)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   tbm_surface_h tbm_surface = NULL;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   tbm_surface = efl_util_screenshot_take_tbm_surface(screenshot);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+   EXPECT_EQ(tbm_surface, nullptr);
+}
+
+TEST_F(EFLUtilInternal, screenshot_set_auto_rotation_p)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   ret = efl_util_screenshot_set_auto_rotation(screenshot, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_set_auto_rotation_n1)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   ret = efl_util_screenshot_set_auto_rotation(screenshot, 2);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_set_auto_rotation_n2)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   ret = efl_util_screenshot_set_auto_rotation(screenshot, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtilInternal, screenshot_get_auto_rotation_p)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int width = 480;
+   int height = 800;
+   int ret = EFL_UTIL_ERROR_NONE;
+   int rotation = 0;
+
+   screenshot = efl_util_screenshot_initialize(width, height);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(screenshot, nullptr);
+
+   ret = efl_util_screenshot_set_auto_rotation(screenshot, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_screenshot_get_auto_rotation(screenshot, &rotation);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(rotation, 1);
+
+   ret = efl_util_screenshot_deinitialize(screenshot);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtilInternal, screenshot_get_auto_rotation_n)
+{
+   efl_util_screenshot_h screenshot = NULL;
+   int ret = EFL_UTIL_ERROR_NONE;
+
+   ret = efl_util_screenshot_get_auto_rotation(screenshot, NULL);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}

diff --git a/test/tc-efl-util.cpp b/test/tc-efl-util.cpp
new file mode 100644 (file)
index 0000000..ff0d12b
--- /dev/null
+++ b/test/tc-efl-util.cpp
@@ -0,0 +1,2024 @@
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tc-efl-util.h"
+
+
+EFLUtil::EFLUtil()
+{
+}
+
+void EFLUtil::SetUp(void)
+{
+   elm_init(0, NULL);
+}
+
+void EFLUtil::TearDown(void)
+{
+   elm_shutdown();
+}
+
+static void
+_win_del(void *data, Evas_Object *obj, void *event)
+{
+   elm_exit();
+}
+
+static Evas_Object *
+_create_normal_win(const char *name)
+{
+   Evas_Object *eo = NULL;
+
+   eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
+   if (eo)
+     {
+        elm_win_title_set(eo, name);
+        elm_win_borderless_set(eo, EINA_TRUE);
+        evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
+        elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
+     }
+
+   return eo;
+}
+
+static Evas_Object *
+_create_notification_win(const char *name)
+{
+   Evas_Object *eo = NULL;
+
+   eo = elm_win_add(NULL, name, ELM_WIN_NOTIFICATION);
+   if (eo)
+     {
+        elm_win_title_set(eo, name);
+        elm_win_borderless_set(eo, EINA_TRUE);
+        evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
+        elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
+     }
+
+   return eo;
+}
+
+static Evas_Object *
+_create_normal_alpha_win(const char *name)
+{
+   Evas_Object *eo = NULL;
+
+   eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
+   if (eo)
+     {
+        elm_win_alpha_set(eo, EINA_TRUE);
+        elm_win_title_set(eo, name);
+        elm_win_borderless_set(eo, EINA_TRUE);
+        evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
+        elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
+     }
+
+   return eo;
+}
+
+TEST_F(EFLUtil, set_notification_window_level_n1)
+{
+   int ret = 0;
+
+   ret = efl_util_set_notification_window_level(NULL,  EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = 0;
+
+   win = _create_normal_win("Normal window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_n3)
+{
+   Evas_Object *win = NULL;
+   int ret = 0;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, (efl_util_notification_level_e)100);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_n1)
+{
+   int ret = 0;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)0;
+
+   ret = efl_util_get_notification_window_level(NULL, &level);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = 0;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)0;
+
+   win = _create_normal_win("Normal Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_get_notification_window_level(win, &level);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p3)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p4)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p5)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p6)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p7)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_notification_window_level_p8)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   ret = efl_util_get_notification_window_level(win, &level);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p3)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p4)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p5)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p6)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p7)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
+}
+
+TEST_F(EFLUtil, get_notification_window_level_p8)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
+
+   win = _create_notification_win("Notification Type Window");
+   EXPECT_NE(win, nullptr);
+
+   efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   evas_object_show(win);
+   ret = efl_util_get_notification_window_level(win, &level);
+
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+}
+
+TEST_F(EFLUtil, set_window_opaque_state_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_alpha_win("Normal Alpha Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_opaque_state(win, 0);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_opaque_state_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_alpha_win("Normal Alpha Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_opaque_state(win, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_opaque_state_n1)
+{
+   int ret = -1;
+
+   ret = efl_util_set_window_opaque_state(NULL, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_window_opaque_state_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_alpha_win("Normal Alpha Window");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_opaque_state(win, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_window_screen_mode_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_screen_mode_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_screen_mode_p3)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_screen_mode_e mode;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_get_window_screen_mode(win, &mode);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_DEFAULT);
+}
+
+TEST_F(EFLUtil, set_window_screen_mode_n1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_window_screen_mode_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, (efl_util_screen_mode_e)3);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_window_screen_mode_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_screen_mode_e mode;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_get_window_screen_mode(win, &mode);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_DEFAULT);
+}
+
+TEST_F(EFLUtil, get_window_screen_mode_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_screen_mode_e mode;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_get_window_screen_mode(win, &mode);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
+}
+
+TEST_F(EFLUtil, get_window_screen_mode_n1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_screen_mode_e mode;
+
+   ret = efl_util_get_window_screen_mode(win, &mode);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_window_screen_mode_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   efl_util_screen_mode_e mode;
+
+   win = _create_normal_win("Screen mode test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_get_window_screen_mode(win, &mode);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_window_brightness_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_brightness(win, 50);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_brightness_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_brightness(win, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, set_window_brightness_n1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   ret = efl_util_set_window_brightness(win, 60);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, set_window_brightness_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_brightness(win, 1000);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_window_brightness_p1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   int brightness = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_brightness(win, 70);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_get_window_brightness(win, &brightness);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(brightness, 70);
+}
+
+TEST_F(EFLUtil, get_window_brightness_p2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   int brightness = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_set_window_brightness(win, -1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_get_window_brightness(win, &brightness);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(brightness, -1);
+}
+
+TEST_F(EFLUtil, get_window_brightness_p3)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   int brightness = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_get_window_brightness(win, &brightness);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_EQ(brightness, -1);
+}
+
+TEST_F(EFLUtil, get_window_brightness_n1)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+   int brightness = -1;
+
+   ret = efl_util_get_window_brightness(win, &brightness);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, get_window_brightness_n2)
+{
+   Evas_Object *win = NULL;
+   int ret = -1;
+
+   win = _create_normal_win("Brightness test");
+   EXPECT_NE(win, nullptr);
+
+   ret = efl_util_get_window_brightness(win, NULL);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_initialize_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_deinitialize_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+
+TEST_F(EFLUtil, gesture_deinitialize_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_p2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 2, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_p3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_BOTTOM);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_p4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_LEFT);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_p5)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_RIGHT);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_NONE);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_new_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_edge_swipe_new(h_gesture, 1, (efl_util_gesture_edge_e)(EFL_UTIL_GESTURE_EDGE_LEFT + 1));
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_size_set_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 359);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_size_set_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_size_set_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 100);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_size_set_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_size_set_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 5, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_free_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_free_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, NULL);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_swipe_free_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, NULL);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_p2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 2, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_p3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_BOTTOM);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_p4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_LEFT);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_p5)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_RIGHT);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_NONE);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_edge_drag_new(h_gesture, 1, (efl_util_gesture_edge_e)((int)EFL_UTIL_GESTURE_EDGE_NONE - 1));
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_new_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_edge_drag_new(h_gesture, 1, (efl_util_gesture_edge_e)((int)EFL_UTIL_GESTURE_EDGE_LEFT + 1));
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_size_set_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 359);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_size_set_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_size_set_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_swipe = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_swipe, nullptr);
+
+   ret = efl_util_gesture_edge_drag_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 100);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_size_set_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_size_set_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 5, 1);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_free_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_edge_drag, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_free_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_edge_drag_free_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_edge_drag = NULL;
+
+   ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_tap_new_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_tap, nullptr);
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_tap_new_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   efl_util_gesture_tap_new(h_gesture, 2, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_tap_new_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_tap_new(h_gesture, 0, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_tap_new_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   efl_util_gesture_tap_new(h_gesture, 2, 1);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_tap_free_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_tap, nullptr);
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_tap_free_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_tap_free_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_palm_cover_new_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_palm_cover_new_n)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+
+   efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_palm_cover_free_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_palm_cover_free_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_palm_cover_free_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_select_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_select_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_select_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_select_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_select_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_tap, nullptr);
+
+   ret = efl_util_gesture_select(h_gesture, win, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_deselect_p)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_deselect_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(EFLUtil, gesture_deselect_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_palm_cover, nullptr);
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_deselect_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_palm_cover = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_deselect_n4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   efl_util_gesture_data d_tap = NULL;
+   Evas_Object *win = NULL;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(d_tap, nullptr);
+
+   ret = efl_util_gesture_deselect(h_gesture, win, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+   ret = efl_util_gesture_tap_free(h_gesture, d_tap);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_p1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_EDGE_SWIPE;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_p2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_EDGE_SWIPE;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_FALSE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_p3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_EDGE_DRAG;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_p4)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_PALM_COVER;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_p5)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_TAP;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_n1)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_TAP;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   evas_object_del(win);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_n2)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   win = _create_normal_win("Gesture Window");
+   EXPECT_NE(win, nullptr);
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_NONE;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   evas_object_del(win);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}
+
+TEST_F(EFLUtil, gesture_activate_set_on_window_n3)
+{
+   int ret = EFL_UTIL_ERROR_NONE;
+   efl_util_gesture_h h_gesture = NULL;
+   Evas_Object *win = NULL;
+   unsigned int type;
+
+   h_gesture = efl_util_gesture_initialize();
+   ret = get_last_result();
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+   EXPECT_NE(h_gesture, nullptr);
+
+   type = EFL_UTIL_GESTURE_TYPE_TAP;
+   ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+   ret = efl_util_gesture_deinitialize(h_gesture);
+   EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
+}

diff --git a/test/tc-efl-util.h b/test/tc-efl-util.h
new file mode 100644 (file)
index 0000000..b54d49b
--- /dev/null
+++ b/test/tc-efl-util.h
@@ -0,0 +1,122 @@
+#ifndef _UT_EFL_UTIL_H_
+#define _UT_EFL_UTIL_H_
+
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <limits.h>
+#include <vector>
+#include <list>
+#include <climits>
+#include <pthread.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <poll.h>
+
+extern "C" {
+#include <tbm_bufmgr.h>
+#include <tbm_drm_helper.h>
+#include <Elementary.h>
+#include <efl_util.h>
+#include <efl_util_screenshot_extension.h>
+#include <tbm_surface.h>
+}
+
+#define EFL_UTIL_UT_ENTRY() \
+   fprintf(stderr, "--------------------------------------------- %s\n", typeid(*this).name());
+
+#define EFL_UTIL_UT_CHECK_FLAG(FLAG) \
+   do \
+     { \
+        if (!(FLAG)) \
+         fprintf(stderr,"[          ] not supported\n"); \
+     } while(0)
+
+#define EFL_UTIL_UT_SKIP_FLAG(FLAG) \
+   do \
+     { \
+        if (!(FLAG)) \
+          { \
+             fprintf(stderr,"[  SKIPPED ] not supported\n"); \
+             return; \
+          } \
+     } while(0)
+
+#define EFL_UTIL_UT_RETURN_IF_FAIL(cond) \
+   do \
+     { \
+        if (!(cond)) \
+          { \
+             fprintf(stderr,"[%s,%d] '%s' failed\n", __FUNCTION__, __LINE__, #cond); \
+             return; \
+          } \
+     } while(0)
+
+#define EFL_UTIL_UT_RETURN_FALSE_IF_FAIL(cond) \
+   do \
+     { \
+        if (!(cond)) \
+          { \
+             fprintf(stderr,"[%s,%d] '%s' failed\n", __FUNCTION__, __LINE__, #cond); \
+             return false; \
+          } \
+     } while(0)
+
+#define EFL_UTIL_UT_RETURN_VAL_IF_FAIL(cond, val) \
+   do \
+     { \
+        if (!(cond)) \
+          { \
+             fprintf(stderr,"[%s,%d] '%s' failed\n", __FUNCTION__, __LINE__, #cond); \
+             return val; \
+          } \
+     } while(0)
+
+#define EFL_UTIL_UT_GOTO_IF_FAIL(cond, dst) \
+   do \
+     { \
+        if (!(cond)) \
+          { \
+             fprintf(stderr,"[%s,%d] '%s' failed\n", __FUNCTION__, __LINE__, #cond); \
+             goto dst; \
+          } \
+     } while(0)
+
+#define EFL_UTIL_UT_ASSERT_TRUE(cond, fmt, args...) \
+        do { \
+                if (!(cond)) { \
+                        GTEST_TEST_BOOLEAN_((cond), #cond, false, true, GTEST_FATAL_FAILURE_); \
+                } \
+        } while(0)
+
+#define EFL_UTIL_UT_EXPECT_TRUE(cond, fmt, args...) \
+        do { \
+                if (!(cond)) { \
+                        GTEST_TEST_BOOLEAN_((cond), #cond, false, true, GTEST_NONFATAL_FAILURE_); \
+                } \
+        } while(0)
+
+using ::testing::Test;
+using ::testing::TestWithParam;
+using ::testing::Bool;
+using ::testing::Values;
+using ::testing::Combine;
+
+class EFLUtil : public Test
+{
+public:
+   EFLUtil();
+   void SetUp(void);
+   void TearDown(void);
+};
+
+class EFLUtilInternal : public EFLUtil
+{
+public:
+   EFLUtilInternal();
+   void SetUp(void);
+   void TearDown(void);
+};
+
+#endif //_UT_EFL_UTIL_H_