Add remote input unittests

lines......: 83.7% (1311 of 1567 lines)
functions..: 100.0% (235 of 235 functions)

Change-Id: Id528f0c7400dc54d15b0f2dc62f1a40e822a7394
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

diff --git a/remote_input/src/remote_input.cpp b/remote_input/src/remote_input.cpp
index 22d224e..a598cb7 100644 (file)
--- a/remote_input/src/remote_input.cpp
+++ b/remote_input/src/remote_input.cpp
@@ -49,6 +49,7 @@ static remote_input_error_e _remote_check_privilege() {
     return ret;
 }
 
+//LCOV_EXCL_START
 static void _metadata_updated_cb(void *user_data, remote_control_entry_metadata_s *data)
 {
     remote_input_h remote_handle = (remote_input_h)user_data;
@@ -98,6 +99,7 @@ static void _resource_updated_cb(void *user_data, remote_control_input_resource
                                            remote_handle->resource_changed_cb_user_data);
     }
 }
+//LCOV_EXCL_STOP
 
 EXPORT_API int remote_input_create(remote_input_h *remote_handle)
 {

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 2359a0e..4907164 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -10,6 +10,7 @@ pkg_check_modules(pkgs REQUIRED
        eina
        ecore-imf
        libscl-core
+       isf
        gmock
 )
 
@@ -27,15 +28,18 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}")
 
 SET(SOURCES "")
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../include)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../inputmethod/include
+                    ${CMAKE_CURRENT_SOURCE_DIR}/../remote_input/include)
 
 AUX_SOURCE_DIRECTORY(src SOURCES)
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../inputmethod/src INPUTMETHOD_SOURCES)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../remote_input/src REMOTE_INPUT_SOURCES)
 
 ADD_DEFINITIONS("-DFULLVER=\"${FULLVER}\"")
 
 ADD_EXECUTABLE(${UNITTEST_INPUTMETHOD}
        ${INPUTMETHOD_SOURCES}
+       ${REMOTE_INPUT_SOURCES}
        ${SOURCES}
        )
 TARGET_LINK_LIBRARIES(${UNITTEST_INPUTMETHOD} ${GTEST_LIBRARIES} ${pkgs_LDFLAGS} ${EXTRA_LDFLAGS})

diff --git a/tests/src/remote_input_unittests.cpp b/tests/src/remote_input_unittests.cpp
new file mode 100644 (file)
index 0000000..2281f31
--- /dev/null
+++ b/tests/src/remote_input_unittests.cpp
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * 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 <gtest/gtest.h>
+#include <remote_input.h>
+
+#include "cynara_mock.h"
+
+namespace {
+
+class RemoteInputTest : public testing::Test {
+    public:
+        virtual void SetUp() {
+            cynara_check_set_result(CYNARA_API_ACCESS_ALLOWED);
+        }
+        virtual void TearDown() {
+        }
+};
+
+class RemoteInputDeniedTest : public testing::Test {
+    public:
+        virtual void SetUp() {
+            cynara_check_set_result(CYNARA_API_ACCESS_DENIED);
+        }
+        virtual void TearDown() {
+            cynara_check_set_result(CYNARA_API_ACCESS_ALLOWED);
+        }
+};
+
+TEST_F(RemoteInputTest, utc_remote_input_error_enum_compatibility_test)
+{
+    EXPECT_EQ(REMOTE_INPUT_INVALID_PARAMETER, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+    EXPECT_EQ(REMOTE_INPUT_OPERATION_FAILED, REMOTE_INPUT_ERROR_OPERATION_FAILED);
+    EXPECT_EQ(REMOTE_INPUT_PERMISSION_DENIED, REMOTE_INPUT_ERROR_PERMISSION_DENIED);
+    EXPECT_EQ(REMOTE_INPUT_OUT_OF_MEMORY, REMOTE_INPUT_ERROR_OUT_OF_MEMORY);
+}
+
+TEST_F(RemoteInputDeniedTest, utc_remote_input_create_permission_denied)
+{
+    remote_input_h ri_h = NULL;
+    int ret = remote_input_create(&ri_h);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_PERMISSION_DENIED);
+
+    if (ri_h)
+        remote_input_destroy(ri_h);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_create_n)
+{
+    int ret = remote_input_create(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_destroy_n)
+{
+    int ret = remote_input_destroy(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_focus_in_callback_set_n)
+{
+    int ret = remote_input_focus_in_callback_set(NULL, NULL, NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_focus_in_callback_unset_n)
+{
+    int ret = remote_input_focus_in_callback_unset(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_focus_out_callback_set_n)
+{
+    int ret = remote_input_focus_out_callback_set(NULL, NULL, NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_focus_out_callback_unset_n)
+{
+    int ret = remote_input_focus_out_callback_unset(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_metadata_updated_callback_set_n)
+{
+    int ret = remote_input_metadata_updated_callback_set(NULL, NULL, NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_metadata_updated_callback_unset_n)
+{
+    int ret = remote_input_metadata_updated_callback_unset(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_text_updated_callback_set_n)
+{
+    int ret = remote_input_text_updated_callback_set(NULL, NULL, NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_text_updated_callback_unset_n)
+{
+    int ret = remote_input_text_updated_callback_unset(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_resource_changed_callback_set_n)
+{
+    int ret = remote_input_resource_changed_callback_set(NULL, NULL, NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_resource_changed_callback_unset_n)
+{
+    int ret = remote_input_resource_changed_callback_unset(NULL);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_input_hint_n)
+{
+    Ecore_IMF_Input_Hints input_hint;
+    int ret = remote_input_get_input_hint(NULL, &input_hint);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_layout_n)
+{
+    Ecore_IMF_Input_Panel_Layout layout;
+    int ret = remote_input_get_layout(NULL, &layout);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_layout_variation_n)
+{
+    int variation;
+    int ret = remote_input_get_layout_variation(NULL, &variation);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_autocapital_type_n)
+{
+    Ecore_IMF_Autocapital_Type autocapital_type;
+    int ret = remote_input_get_autocapital_type(NULL, &autocapital_type);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_return_key_state_n)
+{
+    bool return_key_state;
+    int ret = remote_input_get_return_key_state(NULL, &return_key_state);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_get_return_key_type_n)
+{
+    Ecore_IMF_Input_Panel_Return_Key_Type return_key_type;
+    int ret = remote_input_get_return_key_type(NULL, &return_key_type);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_send_key_event_n)
+{
+    int ret = remote_input_send_key_event(NULL, REMOTE_INPUT_KEY_BACKSPACE);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_send_commit_string_n)
+{
+    int ret = remote_input_send_commit_string(NULL, "Test");
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_update_preedit_string_n)
+{
+    int ret = remote_input_update_preedit_string(NULL, "Test", 4);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(RemoteInputTest, utc_remote_input_delete_surrounding_text_n)
+{
+    int ret = remote_input_delete_surrounding_text(NULL, 0, 1);
+    EXPECT_EQ(ret, REMOTE_INPUT_ERROR_INVALID_PARAMETER);
+}
+
+} // namespace