From b8a6115ec096c3d2e394c3269d13d4695ab7488b Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Thu, 28 Dec 2023 10:37:50 +0900 Subject: [PATCH] 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 --- CMakeLists.txt | 2 + packaging/capi-ui-efl-util.spec | 12 + test/CMakeLists.txt | 38 + test/efl-util-tests.cpp | 66 ++ test/tc-efl-util-internal.cpp | 708 ++++++++++++++ test/tc-efl-util.cpp | 2024 +++++++++++++++++++++++++++++++++++++++ test/tc-efl-util.h | 122 +++ 7 files changed, 2972 insertions(+) create mode 100644 test/CMakeLists.txt create mode 100644 test/efl-util-tests.cpp create mode 100644 test/tc-efl-util-internal.cpp create mode 100644 test/tc-efl-util.cpp create mode 100644 test/tc-efl-util.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 8cb32e0..7779b9c 100644 --- 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 --- 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 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 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 + * Contact: Andrii Sokolenko + * Contact: Roman Marchenko + * + * 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 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 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 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern "C" { +#include +#include +#include +#include +#include +#include +} + +#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_ -- 2.7.4