From e09f94b52546d20a072f7d4343fc7f74f478c8c1 Mon Sep 17 00:00:00 2001 From: Suyeon Hwang Date: Fri, 18 Nov 2022 17:34:19 +0900 Subject: [PATCH] Add unit test cases for enhancing line coverage - Issue: Line coverage of unit test is too low. - Solution: This patch adds new test cases to cover uncovered logics in voice control client library. Through this patch, the line coverage of unit test will be bigger. Change-Id: Ida10976a7bd7bb06c6378d367dfec8df06ecf953 Signed-off-by: Suyeon Hwang --- packaging/voice-control.spec | 7 +- tests/res/test_command.json | 12 + tests/src/test_util.cpp | 57 ++ tests/src/test_util.h | 33 + tests/src/vc_unittests.cpp | 1878 ++++++++++++++++++++++++---------- 5 files changed, 1471 insertions(+), 516 deletions(-) create mode 100644 tests/src/test_util.cpp create mode 100644 tests/src/test_util.h diff --git a/packaging/voice-control.spec b/packaging/voice-control.spec index 799eef6..e318157 100644 --- a/packaging/voice-control.spec +++ b/packaging/voice-control.spec @@ -160,20 +160,21 @@ rm -rf %{buildroot} builddir=$(basename $PWD) gcno_obj_dir=%{buildroot}%{_datadir}/gcov/obj/%{name}/"$builddir" mkdir -p "$gcno_obj_dir" +find ./client/CMakeFiles/vc_* -name '*.gcno' -exec rm {} \; find ./server/ -name '*.gcno' -exec rm {} \; find ./audio-manager/ -name '*.gcno' -exec rm {} \; find ./tests/ -name '*.gcno' -exec rm {} \; find ./engine-parser/ -name '*.gcno' -exec rm {} \; -find . -name '*_client.c.gcno' -exec rm {} \; find . -name '*_dbus.c.gcno' -exec rm {} \; find . -name '*_cmd_db.c.gcno' -exec rm {} \; -find . -name '*_command*.gcno' -exec rm {} \; find . -name '*_config_*.gcno' -exec rm {} \; find . -name '*_parser.c.gcno' -exec rm {} \; -find . -name '*_data*.gcno' -exec rm {} \; find . -name 'vc_mgr*.gcno' -exec rm {} \; find . -name 'vc_setting*.gcno' -exec rm {} \; find . -name 'vc_widget*.gcno' -exec rm {} \; +find . -name 'vc_proxy*.gcno' -exec rm {} \; +find . -name 'vc_command_util*.gcno' -exec rm {} \; +find . -name '*_data*.gcno' -exec rm {} \; find . -name '*.gcno' -exec cp --parents '{}' "$gcno_obj_dir" ';' %endif diff --git a/tests/res/test_command.json b/tests/res/test_command.json index 6ad1064..f0d971c 100644 --- a/tests/res/test_command.json +++ b/tests/res/test_command.json @@ -10,5 +10,17 @@ "domain": "0", "cmd": "zoom" } + ], + "background" : [ + { + "format": "0", + "domain": "0", + "cmd": "capture" + }, + { + "format": "0", + "domain": "0", + "cmd": "zoom" + } ] } \ No newline at end of file diff --git a/tests/src/test_util.cpp b/tests/src/test_util.cpp new file mode 100644 index 0000000..0a0f1c6 --- /dev/null +++ b/tests/src/test_util.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022 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 +#include +#include +#include + +#include "test_util.h" + +void terminate_current_engine() +{ + char* engine_id = vconf_get_str(VCONFKEY_VC_ENGINE_DEFAULT); + + app_context_h context = nullptr; + EXPECT_EQ(app_manager_get_app_context(engine_id, &context), APP_MANAGER_ERROR_NONE); + EXPECT_NE(context, nullptr); + free(engine_id); + + EXPECT_EQ(app_manager_terminate_app(context), APP_MANAGER_ERROR_NONE); + EXPECT_EQ(app_context_destroy(context), APP_MANAGER_ERROR_NONE); +} + +void wait_engine_terminated(int wait_delay) +{ + int max_count = wait_delay * 10; + int count = 0; + + char* engine_id = vconf_get_str(VCONFKEY_VC_ENGINE_DEFAULT); + + while (max_count > count) { + bool is_running = false; + app_manager_is_running(engine_id, &is_running); + + if (false == is_running) { + return; + } + + ecore_main_loop_iterate(); + usleep(100000); + count++; + } +} diff --git a/tests/src/test_util.h b/tests/src/test_util.h new file mode 100644 index 0000000..702831b --- /dev/null +++ b/tests/src/test_util.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2022 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. + */ + + +#ifndef __VC_TEST_UTIL_H__ +#define __VC_TEST_UTIL_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif + +void terminate_current_engine(); +void wait_engine_terminated(int wait_delay); + +#ifdef __cplusplus +} +#endif + +#endif /* __VC_TEST_UTIL_H__ */ \ No newline at end of file diff --git a/tests/src/vc_unittests.cpp b/tests/src/vc_unittests.cpp index 6963fbc..5f71301 100644 --- a/tests/src/vc_unittests.cpp +++ b/tests/src/vc_unittests.cpp @@ -17,18 +17,37 @@ #include #include #include +#include +#include +#include #include +#include #include +#include #include "system_info_mock.h" #include "cynara_mock.h" +#include "test_util.h" + + +static const char *TEST_COMMAND_JSON_PATH = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.vc-unittests/res/test_command.json"); +static const char *TEST_APP_ID = "org.tizen.vc-unittests"; +static const char *TEST_INVOCATION_NAME = "invocation"; +static const char *TEST_CREDENTIAL = "credential"; + static int g_vc_init = false; static vc_state_e g_vc_state = VC_STATE_NONE; +static vc_service_state_e g_vc_service_state = VC_SERVICE_STATE_NONE; + static vc_state_e g_vc_mgr_state = VC_STATE_NONE; static vc_service_state_e g_vc_mgr_service_state = VC_SERVICE_STATE_NONE; static bool g_vc_supported = false; +static bool g_error_cb_invoked = false; + +vc_cmd_list_h g_test_commands = nullptr; + static bool __is_mgr_state_changed(vc_state_e state, int wait_delay) { int max_count = wait_delay * 10; @@ -63,6 +82,60 @@ static bool __is_mgr_service_state_changed(vc_service_state_e state, int wait_de return true; } +static bool __is_state_changed(vc_state_e state, int wait_delay) +{ + int max_count = wait_delay * 10; + int count = 0; + while (max_count > count && state != g_vc_state) { + ecore_main_loop_iterate(); + usleep(100000); + count++; + } + + return (state == g_vc_state); +} + +static bool __is_service_state_changed(vc_service_state_e state, int wait_delay) +{ + int max_count = wait_delay * 10; + int count = 0; + while (max_count > count && state != g_vc_service_state) { + ecore_main_loop_iterate(); + usleep(100000); + count++; + } + + return (state == g_vc_service_state); +} + +static bool __is_error_cb_invoked(int wait_delay) +{ + int max_count = wait_delay * 10; + int count = 0; + while (max_count > count && false == g_error_cb_invoked) { + ecore_main_loop_iterate(); + usleep(100000); + count++; + } + + return g_error_cb_invoked; +} + +static void __vc_mgr_state_changed_cb(vc_state_e previous, vc_state_e current, void* user_data) +{ + g_vc_mgr_state = current; +} + +static void __vc_mgr_service_state_changed_cb(vc_service_state_e previous, vc_service_state_e current, void* user_data) +{ + g_vc_mgr_service_state = current; +} + +static bool __vc_mgr_all_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char *result, const char *msg, void *user_data) +{ + return true; +} + static void __vc_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, void* user_data) { } @@ -81,21 +154,21 @@ static void __vc_state_changed_cb(vc_state_e previous, vc_state_e current, void* g_vc_state = current; } -static void __vc_mgr_state_changed_cb(vc_state_e previous, vc_state_e current, void* user_data) +static void __vc_service_state_changed_cb(vc_service_state_e previous, vc_service_state_e current, void* user_data) { - g_vc_mgr_state = current; + g_vc_service_state = current; } -static void __vc_mgr_service_state_changed_cb(vc_service_state_e previous, vc_service_state_e current, void* user_data) +static void __vc_error_cb(vc_error_e reason, void* user_data) { - g_vc_mgr_service_state = current; + g_error_cb_invoked = true; } -static void __vc_service_state_changed_cb(vc_service_state_e previous, vc_service_state_e current, void* user_data) +static void __vc_tts_streaming_cb(vc_tts_event_e event, char* buffer, int len, int utt_id, void *user_data) { } -static void __vc_error_cb(vc_error_e reason, void* user_data) +static void __vc_tts_utterance_status_cb(int utt_id, vc_tts_utterance_status_e status, void *user_data) { } @@ -109,13 +182,14 @@ static void __vc_mgr_ready() EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE); EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NONE); EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NONE); + EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NONE); EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE); ASSERT_EQ(true, __is_mgr_state_changed(VC_STATE_READY, 5)); ASSERT_EQ(true, __is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5)); vc_cmd_h system_command = nullptr; EXPECT_EQ(vc_cmd_create(&system_command), VC_ERROR_NONE); - EXPECT_EQ(vc_cmd_set_command(system_command, "test"), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_command(system_command, "manager"), VC_ERROR_NONE); EXPECT_EQ(vc_cmd_set_type(system_command, VC_COMMAND_TYPE_SYSTEM), VC_ERROR_NONE); vc_cmd_list_h commands = nullptr; @@ -152,15 +226,67 @@ static bool __is_vc_supported() return (is_vc_supported && is_mic_supported); } +static vc_cmd_list_h __create_test_command_list() +{ + vc_cmd_h system_command = nullptr; + EXPECT_EQ(vc_cmd_create(&system_command), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_command(system_command, "test"), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_type(system_command, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE); + + vc_cmd_list_h commands = nullptr; + EXPECT_EQ(vc_cmd_list_create(&commands), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_add(commands, system_command), VC_ERROR_NONE); + + return commands; +} + +static void __initialize_test_environment() +{ + ecore_init(); + ecore_main_loop_glib_integrate(); + + g_vc_supported = __is_vc_supported(); + + g_vc_mgr_state = VC_STATE_NONE; + g_vc_mgr_service_state = VC_SERVICE_STATE_NONE; + + g_vc_state = VC_STATE_NONE; + g_vc_service_state = VC_SERVICE_STATE_NONE; + + g_error_cb_invoked = false; + + g_test_commands = __create_test_command_list(); +} + +static void __shutdown_test_environment() +{ + vc_cmd_list_destroy(g_test_commands, true); + g_test_commands = nullptr; + + wait_engine_terminated(1); + + ecore_shutdown(); +} + namespace { +class VCTestInNoneState : public testing::Test { + public: + virtual void SetUp() { + __initialize_test_environment(); + } + + virtual void TearDown() + { + vc_deinitialize(); + __shutdown_test_environment(); + } +}; + class VCTest : public testing::Test { public: virtual void SetUp() { - ecore_init(); - ecore_main_loop_glib_integrate(); - - g_vc_supported = __is_vc_supported(); + __initialize_test_environment(); if (false == g_vc_supported) { g_vc_init = false; @@ -170,17 +296,49 @@ class VCTest : public testing::Test { g_vc_init = true; vc_initialize(); vc_set_state_changed_cb(__vc_state_changed_cb, NULL); + vc_set_service_state_changed_cb(__vc_service_state_changed_cb, nullptr); + } + + virtual void TearDown() + { + if (true == g_vc_supported) + { + vc_unset_state_changed_cb(); + vc_deinitialize(); + } + + __shutdown_test_environment(); + } +}; + +class VCTestInReadyState : public testing::Test { + public: + virtual void SetUp() { + __initialize_test_environment(); + + if (false == g_vc_supported) { + return; + } + + vc_initialize(); + vc_set_state_changed_cb(__vc_state_changed_cb, nullptr); + vc_set_service_state_changed_cb(__vc_service_state_changed_cb, nullptr); + + vc_prepare_sync(); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + EXPECT_EQ(__is_service_state_changed(VC_SERVICE_STATE_READY, 5), true); } virtual void TearDown() { if (true == g_vc_supported) { + vc_unprepare(); vc_unset_state_changed_cb(); vc_deinitialize(); } - ecore_shutdown(); + __shutdown_test_environment(); } }; @@ -215,6 +373,37 @@ TEST_F(VCTest, vc_deinitialize_p) } } +/** + * @testcase utc_vc_deinitialize_p2 + * @since_tizen 2.4 + * @description Positive UTC for deinitialize voice control handle + */ +TEST_F(VCTest, utc_vc_deinitialize_p2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_prepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_deinitialize_p3 + * @since_tizen 2.4 + * @description Positive UTC for deinitialize voice control handle + */ +TEST_F(VCTestInReadyState, utc_vc_deinitialize_p3) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + /** * @testcase utc_vc_deinitialize_n * @since_tizen 2.4 @@ -274,23 +463,67 @@ TEST_F(VCTest, vc_prepare_p) * @since_tizen 2.4 * @description Negative UTC for connect service daemon (Invalid state) */ -TEST_F(VCTest, vc_prepare_n) +TEST_F(VCTestInNoneState, utc_vc_prepare_n) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_prepare(), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_prepare(); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_prepare(), VC_ERROR_INVALID_STATE); - vc_deinitialize(); + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_set_state_changed_cb(__vc_state_changed_cb, nullptr), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_prepare(); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); + EXPECT_EQ(vc_prepare(), VC_ERROR_NONE); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + EXPECT_EQ(vc_prepare(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_prepare_sync_p + * @since_tizen 4.0 + * @description Positive UTC for connect service engine synchronously + */ +TEST_F(VCTest, utc_vc_prepare_sync_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_prepare_sync_n + * @since_tizen 4.0 + * @description Negative UTC for connect service engine synchronously (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_prepare_sync_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_set_state_changed_cb(__vc_state_changed_cb, nullptr), VC_ERROR_NONE); + + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -327,46 +560,19 @@ TEST_F(VCTest, vc_unprepare_p) * @since_tizen 2.4 * @description Negative UTC for disconnect service daemon (Invalid state) */ -TEST_F(VCTest, vc_unprepare_n) +TEST_F(VCTestInNoneState, utc_vc_unprepare_n) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); + EXPECT_EQ(vc_unprepare(), VC_ERROR_NOT_SUPPORTED); + return; } -} - -/** - * @testcase utc_vc_unprepare_n2 - * @since_tizen 2.4 - * @description Negative UTC for disconnect service daemon (Invalid state) - */ -TEST_F(VCTest, vc_unprepare_n2) -{ - if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - int ret = VC_ERROR_NONE; - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_unprepare(), VC_ERROR_INVALID_STATE); - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_unprepare(), VC_ERROR_INVALID_STATE); - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); - } + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -532,57 +738,29 @@ TEST_F(VCTest, vc_get_current_language_n2) * @since_tizen 2.4 * @description Positive UTC for get current state */ -TEST_F(VCTest, vc_get_state_p) +TEST_F(VCTestInNoneState, vc_get_state_p) { + vc_state_e state = VC_STATE_NONE; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_get_state(&state), VC_ERROR_NOT_SUPPORTED); + return; } -} - -/** - * @testcase utc_vc_get_state_p2 - * @since_tizen 2.4 - * @description Positive UTC for get current state after connection - */ -TEST_F(VCTest, vc_get_state_p2) -{ - if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - int ret = VC_ERROR_NONE; - ret = vc_prepare(); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_get_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_STATE_NONE); - while (VC_STATE_READY != g_vc_state) { - ecore_main_loop_iterate(); - } + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_get_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_STATE_INITIALIZED); - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_set_state_changed_cb(__vc_state_changed_cb, nullptr), VC_ERROR_NONE); + EXPECT_EQ(vc_prepare(), VC_ERROR_NONE); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + EXPECT_EQ(vc_get_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_STATE_READY); - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_NONE); - } + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -608,113 +786,79 @@ TEST_F(VCTest, vc_get_state_n) } /** - * @testcase utc_vc_get_state_n2 + * @testcase utc_vc_get_service_state_p * @since_tizen 2.4 - * @description Negative UTC for get current state (Invalid state) + * @description Positive UTC for get current state of service daemon */ -TEST_F(VCTest, vc_get_state_n2) +TEST_F(VCTestInReadyState, utc_vc_get_service_state_p) { + vc_service_state_e state = VC_SERVICE_STATE_NONE; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_SERVICE_STATE_READY); - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); + __vc_mgr_ready(); - vc_state_e state = VC_STATE_NONE; - ret = vc_get_state(&state); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); - } + EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE); + EXPECT_EQ(__is_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true); + + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_SERVICE_STATE_RECORDING); + + EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE); + EXPECT_EQ(__is_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true); + + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_NONE); + EXPECT_EQ(state, VC_SERVICE_STATE_PROCESSING); + + __vc_mgr_finish(); } /** - * @testcase utc_vc_get_service_state_p + * @testcase utc_vc_get_service_state_n * @since_tizen 2.4 - * @description Positive UTC for get current state of service daemon + * @description Negative UTC for get current state of service daemon (Invalid parameter) */ -TEST_F(VCTest, vc_get_service_state_p) +TEST_F(VCTest, vc_get_service_state_n) { if (false == g_vc_supported) { EXPECT_EQ(g_vc_init, false); int ret = VC_ERROR_NONE; - vc_service_state_e state = VC_SERVICE_STATE_NONE; - ret = vc_get_service_state(&state); + ret = vc_get_service_state(NULL); EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); } else { EXPECT_EQ(g_vc_init, true); int ret = VC_ERROR_NONE; - ret = vc_prepare(); - EXPECT_EQ(ret, VC_ERROR_NONE); - - while (VC_STATE_READY != g_vc_state) { - ecore_main_loop_iterate(); - } - - vc_service_state_e state = VC_SERVICE_STATE_NONE; - ret = vc_get_service_state(&state); - EXPECT_EQ(ret, VC_ERROR_NONE); - - ret = vc_unprepare(); - EXPECT_EQ(ret, VC_ERROR_NONE); - } -} - -/** - * @testcase utc_vc_get_service_state_n - * @since_tizen 2.4 - * @description Negative UTC for get current state of service daemon (Invalid parameter) - */ -TEST_F(VCTest, vc_get_service_state_n) -{ - if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - ret = vc_get_service_state(NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - ret = vc_get_service_state(NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } -} + ret = vc_get_service_state(NULL); + EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + } +} /** * @testcase utc_vc_get_service_state_n2 * @since_tizen 2.4 * @description Negative UTC for get current state of service daemon (Invalid state) */ -TEST_F(VCTest, vc_get_service_state_n2) +TEST_F(VCTestInNoneState, vc_get_service_state_n2) { + vc_service_state_e state = VC_SERVICE_STATE_NONE; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - vc_service_state_e state = VC_SERVICE_STATE_NONE; - ret = vc_get_service_state(&state); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_INVALID_STATE); - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_get_service_state(&state), VC_ERROR_INVALID_STATE); - vc_service_state_e state = VC_SERVICE_STATE_NONE; - ret = vc_get_service_state(&state); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); - } + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -826,26 +970,18 @@ TEST_F(VCTest, vc_get_system_command_list_n) * @since_tizen 3.0 * @description Negative UTC for get the system command list (Invalid state) */ -TEST_F(VCTest, vc_get_system_command_list_n2) +TEST_F(VCTestInNoneState, vc_get_system_command_list_n2) { + vc_cmd_list_h list = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_get_system_command_list(&list); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_get_system_command_list(&list), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_get_system_command_list(&list), VC_ERROR_INVALID_STATE); - vc_cmd_list_h list = NULL; - ret = vc_get_system_command_list(&list); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); - } + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_get_system_command_list(&list), VC_ERROR_INVALID_STATE); } /** @@ -906,21 +1042,23 @@ TEST_F(VCTest, vc_set_command_list_p) * @since_tizen 2.4 * @description Negative UTC for set command list used as candidate set (Invalid parameter) */ -TEST_F(VCTest, vc_set_command_list_n) +TEST_F(VCTestInReadyState, utc_vc_set_command_list_n) { - if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - ret = vc_set_command_list(NULL, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + vc_cmd_list_h empty_cmd_list = nullptr; + EXPECT_EQ(vc_cmd_list_create(&empty_cmd_list), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_set_command_list(NULL, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_command_list(nullptr, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_set_command_list(empty_cmd_list, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_set_command_list(g_test_commands, -1), VC_ERROR_NOT_SUPPORTED); + vc_cmd_list_destroy(empty_cmd_list, true); + return; } + + EXPECT_EQ(vc_set_command_list(nullptr, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_set_command_list(empty_cmd_list, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_set_command_list(g_test_commands, -1), VC_ERROR_INVALID_PARAMETER); + vc_cmd_list_destroy(empty_cmd_list, true); } /** @@ -928,62 +1066,19 @@ TEST_F(VCTest, vc_set_command_list_n) * @since_tizen 2.4 * @description Negative UTC for set command list used as candidate set (Invalid state) */ -TEST_F(VCTest, vc_set_command_list_n2) +TEST_F(VCTestInNoneState, utc_vc_set_command_list_n2) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); - - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NONE); - - ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); - - ret = vc_cmd_list_destroy(list, true); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_set_command_list(g_test_commands, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NOT_SUPPORTED); + return; } -} - -/** - * @testcase utc_vc_set_command_list_n3 - * @since_tizen 2.4 - * @description Negative UTC for set command list used as candidate set (Invalid state) - */ -TEST_F(VCTest, vc_set_command_list_n3) -{ - if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_set_command_list(g_test_commands, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_STATE); - ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_set_command_list(g_test_commands, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_STATE); - ret = vc_cmd_list_destroy(list, true); - EXPECT_EQ(ret, VC_ERROR_NONE); - } + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -1044,23 +1139,16 @@ TEST_F(VCTest, vc_unset_command_list_p) /** * @testcase utc_vc_unset_command_list_n * @since_tizen 2.4 - * @description Negative UTC for unset command list used as candidate set (Invalid state) + * @description Negative UTC for unset command list used as candidate set (Invalid parameter) */ -TEST_F(VCTest, vc_unset_command_list_n) +TEST_F(VCTestInReadyState, utc_vc_unset_command_list_n) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); + EXPECT_EQ(vc_unset_command_list(-1), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_unset_command_list(-1), VC_ERROR_INVALID_PARAMETER); } /** @@ -1068,24 +1156,75 @@ TEST_F(VCTest, vc_unset_command_list_n) * @since_tizen 2.4 * @description Negative UTC for unset command list used as candidate set (Invalid state) */ -TEST_F(VCTest, vc_unset_command_list_n2) +TEST_F(VCTestInNoneState, utc_vc_unset_command_list_n2) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_STATE); - int ret = VC_ERROR_NONE; - ret = vc_deinitialize(); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_INVALID_STATE); - ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_STATE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_set_command_list_from_file_p + * @since_tizen 2.4 + * @description Positive UTC for set command list used as candidate set from file + */ +TEST_F(VCTestInReadyState, utc_vc_set_command_list_from_file_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_invocation_name(TEST_INVOCATION_NAME), VC_ERROR_NONE); + + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE); + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_set_command_list_from_file_n + * @since_tizen 2.4 + * @description Negative UTC for set command list used as candidate set from file (Invalid parameter) + */ +TEST_F(VCTestInReadyState, utc_vc_set_command_list_from_file_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase utc_vc_set_command_list_from_file_n2 + * @since_tizen 2.4 + * @description Negative UTC for set command list used as candidate set from file (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_set_command_list_from_file_n2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); } /** @@ -1865,6 +2004,32 @@ TEST_F(VCTest, vc_set_error_cb_p) } } +/** + * @testcase utc_vc_set_error_cb_p2 + * @since_tizen 2.4 + * @description Positive UTC for set error callback + */ +TEST_F(VCTest, utc_vc_set_error_cb_p2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_error_cb(__vc_error_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_error_cb(__vc_error_cb, nullptr), VC_ERROR_NONE); + + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + EXPECT_EQ(__is_service_state_changed(VC_SERVICE_STATE_READY, 5), true); + + terminate_current_engine(); + + EXPECT_EQ(__is_error_cb_invoked(5), true); + EXPECT_EQ(__is_state_changed(VC_STATE_READY, 5), true); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); +} + /** * @testcase utc_vc_set_error_cb_n * @since_tizen 2.4 @@ -2025,6 +2190,7 @@ TEST_F(VCTest, vc_unset_error_cb_n2) } } +// TODO: invalid parameter TC is needed? /** * @testcase utc_vc_set_invocation_name_p * @since_tizen 3.0 @@ -2055,6 +2221,9 @@ TEST_F(VCTest, vc_set_invocation_name_p) ret = vc_set_invocation_name(invoc_name); EXPECT_EQ(ret, VC_ERROR_NONE); + ret = vc_set_invocation_name(invoc_name); + EXPECT_EQ(ret, VC_ERROR_NONE); + ret = vc_unprepare(); EXPECT_EQ(ret, VC_ERROR_NONE); } @@ -2085,6 +2254,92 @@ TEST_F(VCTest, vc_set_invocation_name_n) } } +/** + * @testcase utc_vc_set_server_dialog_p + * @since_tizen 5.0 + * @description Positive UTC for setting the server dialog + */ +TEST_F(VCTestInReadyState, utc_vc_set_server_dialog_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, TEST_CREDENTIAL), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, TEST_CREDENTIAL), VC_ERROR_NONE); + EXPECT_EQ(vc_set_server_dialog(nullptr, TEST_CREDENTIAL), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_set_server_dialog_n + * @since_tizen 5.0 + * @description Negative UTC for setting the server dialog (Invalid parameter) + */ +TEST_F(VCTestInReadyState, utc_vc_set_server_dialog_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, nullptr), VC_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase utc_vc_set_server_dialog_n2 + * @since_tizen 5.0 + * @description Negative UTC for setting the server dialog (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_set_server_dialog_n2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, TEST_CREDENTIAL), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, TEST_CREDENTIAL), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_set_server_dialog(TEST_APP_ID, TEST_CREDENTIAL), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_unset_server_dialog_p + * @since_tizen 5.0 + * @description Positive UTC for setting the server dialog + */ +TEST_F(VCTestInReadyState, utc_vc_unset_server_dialog_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_unset_server_dialog(TEST_APP_ID), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_unset_server_dialog(TEST_APP_ID), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_unset_server_dialog_n + * @since_tizen 5.0 + * @description Negative UTC for setting the server dialog (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_unset_server_dialog_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_unset_server_dialog(TEST_APP_ID), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_unset_server_dialog(TEST_APP_ID), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_unset_server_dialog(TEST_APP_ID), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + /** * @testcase utc_vc_request_dialog_p * @since_tizen 3.0 @@ -2155,78 +2410,253 @@ TEST_F(VCTest, vc_request_dialog_n) } /** - * @testcase utc_vc_cmd_list_create_p - * @since_tizen 2.4 - * @description Positive UTC for create command list handle + * @testcase utc_vc_tts_set_streaming_cb_p + * @since_tizen 5.5 + * @description Positive UTC for setting tts streaming callback */ -TEST_F(VCTest, vc_cmd_list_create_p) +TEST_F(VCTest, utc_vc_tts_set_streaming_cb_p) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NONE); - - vc_cmd_list_destroy(list, false); + EXPECT_EQ(vc_tts_set_streaming_cb(__vc_tts_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_tts_set_streaming_cb(__vc_tts_streaming_cb, nullptr), VC_ERROR_NONE); } /** - * @testcase utc_vc_cmd_list_create_n - * @since_tizen 2.4 - * @description Negative UTC for create command list handle (Invalid parameter) + * @testcase utc_vc_tts_set_streaming_cb_n + * @since_tizen 5.5 + * @description Negative UTC for setting tts streaming callback (Invalid parameter) */ -TEST_F(VCTest, vc_cmd_list_create_n) +TEST_F(VCTest, utc_vc_tts_set_streaming_cb_n) { if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_tts_set_streaming_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_set_streaming_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase utc_vc_tts_set_streaming_cb_n2 + * @since_tizen 5.5 + * @description Negative UTC for setting tts streaming callback (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_tts_set_streaming_cb_n2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_set_streaming_cb(__vc_tts_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_set_streaming_cb(__vc_tts_streaming_cb, nullptr), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + + EXPECT_EQ(vc_tts_set_streaming_cb(__vc_tts_streaming_cb, nullptr), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_unset_streaming_cb_p + * @since_tizen 5.5 + * @description Positive UTC for unsetting tts streaming callback + */ +TEST_F(VCTest, utc_vc_tts_unset_streaming_cb_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_unset_streaming_cb(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_unset_streaming_cb(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_unset_streaming_cb_n + * @since_tizen 5.5 + * @description Negative UTC for unsetting tts streaming callback (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_tts_unset_streaming_cb_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_unset_streaming_cb(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_unset_streaming_cb(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + + EXPECT_EQ(vc_tts_unset_streaming_cb(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_set_utterance_status_cb_p + * @since_tizen 5.5 + * @description Positive UTC for setting tts utterance status callback + */ +TEST_F(VCTest, utc_vc_tts_set_utterance_status_cb_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_set_utterance_status_cb(__vc_tts_utterance_status_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_set_utterance_status_cb(__vc_tts_utterance_status_cb, nullptr), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_set_utterance_status_cb_n + * @since_tizen 5.5 + * @description Negative UTC for setting tts utterance status callback (Invalid parameter) + */ +TEST_F(VCTest, utc_vc_tts_set_utterance_status_cb_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_set_utterance_status_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_set_utterance_status_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase utc_vc_tts_set_utterance_status_cb_n2 + * @since_tizen 5.5 + * @description Negative UTC for setting tts utterance status callback (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_tts_set_utterance_status_cb_n2) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_set_utterance_status_cb(__vc_tts_utterance_status_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_set_utterance_status_cb(__vc_tts_utterance_status_cb, nullptr), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + + EXPECT_EQ(vc_tts_set_utterance_status_cb(__vc_tts_utterance_status_cb, nullptr), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_unset_utterance_status_cb_p + * @since_tizen 5.5 + * @description Positive UTC for unsetting tts utterance status callback + */ +TEST_F(VCTest, utc_vc_tts_unset_utterance_status_cb_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_unset_utterance_status_cb(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_unset_utterance_status_cb(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_tts_unset_utterance_status_cb_n + * @since_tizen 5.5 + * @description Negative UTC for unsetting tts utterance status callback (Invalid state) + */ +TEST_F(VCTestInNoneState, utc_vc_tts_unset_utterance_status_cb_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_tts_unset_utterance_status_cb(), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_tts_unset_utterance_status_cb(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_initialize(), VC_ERROR_NONE); + EXPECT_EQ(vc_prepare_sync(), VC_ERROR_NONE); + + EXPECT_EQ(vc_tts_unset_utterance_status_cb(), VC_ERROR_INVALID_STATE); + + EXPECT_EQ(vc_unprepare(), VC_ERROR_NONE); + EXPECT_EQ(vc_deinitialize(), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_create_p + * @since_tizen 2.4 + * @description Positive UTC for create command list handle + */ +TEST_F(VCTest, vc_cmd_list_create_p) +{ + if (false == g_vc_supported) { + EXPECT_EQ(g_vc_init, false); int ret = VC_ERROR_NONE; - ret = vc_cmd_list_create(NULL); + vc_cmd_list_h list = NULL; + ret = vc_cmd_list_create(&list); EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); } else { EXPECT_EQ(g_vc_init, true); int ret = VC_ERROR_NONE; - ret = vc_cmd_list_create(NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + vc_cmd_list_h list = NULL; + ret = vc_cmd_list_create(&list); + EXPECT_EQ(ret, VC_ERROR_NONE); + + vc_cmd_list_destroy(list, false); } } /** - * @testcase utc_vc_cmd_list_destroy_p + * @testcase utc_vc_cmd_list_create_n * @since_tizen 2.4 - * @description Positive UTC for destroy command list handle + * @description Negative UTC for create command list handle (Invalid parameter) */ -TEST_F(VCTest, vc_cmd_list_destroy_p) +TEST_F(VCTest, vc_cmd_list_create_n) { if (false == g_vc_supported) { EXPECT_EQ(g_vc_init, false); int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_destroy(list, false); + ret = vc_cmd_list_create(NULL); EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); } else { EXPECT_EQ(g_vc_init, true); int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NONE); + ret = vc_cmd_list_create(NULL); + EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + } +} - ret = vc_cmd_list_destroy(list, false); - EXPECT_EQ(ret, VC_ERROR_NONE); +/** + * @testcase utc_vc_cmd_list_destroy_p + * @since_tizen 2.4 + * @description Positive UTC for destroy command list handle + */ +TEST_F(VCTest, vc_cmd_list_destroy_p) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_destroy(list, false), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_destroy(list, false), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); } /** @@ -2258,28 +2688,26 @@ TEST_F(VCTest, vc_cmd_list_destroy_n) */ TEST_F(VCTest, vc_cmd_list_get_count_p) { + vc_cmd_list_h list = nullptr; + int cnt = -1; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - int cnt = -1; - ret = vc_cmd_list_get_count(list, &cnt); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - vc_cmd_list_h list = NULL; - ret = vc_cmd_list_create(&list); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 0); - int cnt = -1; - ret = vc_cmd_list_get_count(list, &cnt); - EXPECT_EQ(ret, VC_ERROR_NONE); + vc_cmd_h command = nullptr; + EXPECT_EQ(vc_cmd_create(&command), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_add(list, command), VC_ERROR_NONE); - vc_cmd_list_destroy(list, false); - } + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 1); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); } /** @@ -2289,19 +2717,19 @@ TEST_F(VCTest, vc_cmd_list_get_count_p) */ TEST_F(VCTest, vc_cmd_list_get_count_n) { + vc_cmd_list_h list = nullptr; + int cnt = 0; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_get_count(nullptr, &cnt), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_get_count(list, nullptr), VC_ERROR_NOT_SUPPORTED); + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_get_count(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_get_count(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } + EXPECT_EQ(vc_cmd_list_get_count(nullptr, &cnt), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_get_count(list, nullptr), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_list_destroy(list, false), VC_ERROR_NONE); } /** @@ -2345,19 +2773,21 @@ TEST_F(VCTest, vc_cmd_list_add_p) */ TEST_F(VCTest, vc_cmd_list_add_n) { + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_add(list, nullptr), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_add(nullptr, cmd), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_add(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_add(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } + EXPECT_EQ(vc_cmd_list_add(list, nullptr), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_add(nullptr, cmd), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); } /** @@ -2404,19 +2834,79 @@ TEST_F(VCTest, vc_cmd_list_remove_p) */ TEST_F(VCTest, vc_cmd_list_remove_n) { + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_remove(list, nullptr), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_remove(nullptr, cmd), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_remove(list, cmd), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_remove(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_remove(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_remove(list, nullptr), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_remove(nullptr, cmd), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_remove(list, cmd), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_list_destroy(list, false), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_remove_all_p + * @since_tizen 2.4 + * @description Positive UTC for destroy command list handle + */ +TEST_F(VCTest, utc_vc_cmd_list_remove_all_p) +{ + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; + int cnt = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_remove_all(list, false), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_remove_all(list, true), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_list_add(list, cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 1); + + EXPECT_EQ(vc_cmd_list_remove_all(list, false), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 0); + + EXPECT_EQ(vc_cmd_list_add(list, cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 1); + + EXPECT_EQ(vc_cmd_list_remove_all(list, true), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 0); + + EXPECT_EQ(vc_cmd_list_destroy(list, false), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_remove_all_n + * @since_tizen 2.4 + * @description Negative UTC for destroy command list handle (invalid parameter) + */ +TEST_F(VCTest, utc_vc_cmd_list_remove_all_n) +{ + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_remove_all(nullptr, false), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_remove_all(nullptr, true), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_cmd_list_remove_all(nullptr, false), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_remove_all(nullptr, true), VC_ERROR_INVALID_PARAMETER); } /** @@ -2462,19 +2952,70 @@ TEST_F(VCTest, vc_cmd_list_foreach_commands_p) */ TEST_F(VCTest, vc_cmd_list_foreach_commands_n) { + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_foreach_commands(list, nullptr, nullptr), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_foreach_commands(nullptr, __vc_cmd_list_cb, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_foreach_commands(NULL, NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_add(list, cmd), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_foreach_commands(NULL, NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_foreach_commands(list, nullptr, nullptr), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_foreach_commands(nullptr, __vc_cmd_list_cb, nullptr), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_filter_by_type_p + * @since_tizen 3.0 + * @description Positive UTC for get filtered command list by type + */ +TEST_F(VCTest, utc_vc_cmd_list_filter_by_type_p) +{ + vc_cmd_list_h list = nullptr; + int cnt = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_FOREGROUND, &list), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_BACKGROUND, &list), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_FOREGROUND, &list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 1); + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); + list = nullptr; + + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_BACKGROUND, &list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_count(list, &cnt), VC_ERROR_NONE); + EXPECT_EQ(cnt, 0); + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); + list = nullptr; +} + +/** + * @testcase utc_vc_cmd_list_filter_by_type_n + * @since_tizen 3.0 + * @description Negative UTC for get filtered command list by type (invalid parameter) + */ +TEST_F(VCTest, utc_vc_cmd_list_filter_by_type_n) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_filter_by_type(nullptr, VC_COMMAND_TYPE_FOREGROUND, &list), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, -1, &list), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_FOREGROUND, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_filter_by_type(nullptr, VC_COMMAND_TYPE_FOREGROUND, &list), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, -1, &list), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_filter_by_type(g_test_commands, VC_COMMAND_TYPE_FOREGROUND, nullptr), VC_ERROR_INVALID_PARAMETER); } /** @@ -2535,6 +3076,25 @@ TEST_F(VCTest, vc_cmd_list_first_n) } } +/** + * @testcase utc_vc_cmd_list_first_n2 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to the first of command list (Empty list) + */ +TEST_F(VCTest, utc_vc_cmd_list_first_n2) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_first(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_first(list), VC_ERROR_EMPTY); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + /** * @testcase utc_vc_cmd_list_last_p * @since_tizen 2.4 @@ -2593,6 +3153,25 @@ TEST_F(VCTest, vc_cmd_list_last_n) } } +/** + * @testcase utc_vc_cmd_list_last_n2 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to the last of command list (Empty list) + */ +TEST_F(VCTest, utc_vc_cmd_list_last_n2) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_last(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_last(list), VC_ERROR_EMPTY); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + /** * @testcase utc_vc_cmd_list_next_p * @since_tizen 2.4 @@ -2657,6 +3236,48 @@ TEST_F(VCTest, vc_cmd_list_next_n) } } +/** + * @testcase utc_vc_cmd_list_next_n2 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to next command in command list (Empty list) + */ +TEST_F(VCTest, utc_vc_cmd_list_next_n2) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_last(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_next(list), VC_ERROR_EMPTY); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_next_n3 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to next command in command list (Iteration end) + */ +TEST_F(VCTest, utc_vc_cmd_list_next_n3) +{ + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_next(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_add(list, cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_list_next(list), VC_ERROR_ITERATION_END); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + /** * @testcase utc_vc_cmd_list_prev_p * @since_tizen 2.4 @@ -2721,6 +3342,48 @@ TEST_F(VCTest, vc_cmd_list_prev_n) } } +/** + * @testcase utc_vc_cmd_list_prev_n2 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to next command in command list (Empty list) + */ +TEST_F(VCTest, utc_vc_cmd_list_prev_n2) +{ + vc_cmd_list_h list = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_prev(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_prev(list), VC_ERROR_EMPTY); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_list_prev_n3 + * @since_tizen 2.4 + * @description Negative UTC for move pointer to next command in command list (Iteration end) + */ +TEST_F(VCTest, utc_vc_cmd_list_prev_n3) +{ + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_prev(list), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_add(list, cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_list_prev(list), VC_ERROR_ITERATION_END); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); +} + /** * @testcase utc_vc_cmd_list_get_current_p * @since_tizen 2.4 @@ -2769,19 +3432,36 @@ TEST_F(VCTest, vc_cmd_list_get_current_p) */ TEST_F(VCTest, vc_cmd_list_get_current_n) { + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_list_get_current(list, &cmd), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_list_get_current(list, &cmd), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_get_current(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_list_get_current(nullptr, &cmd), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_list_get_current(list, nullptr), VC_ERROR_INVALID_PARAMETER); +} - int ret = VC_ERROR_NONE; - ret = vc_cmd_list_get_current(NULL, NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); +/** + * @testcase utc_vc_cmd_list_get_current_n2 + * @since_tizen 2.4 + * @description Negative UTC for get command handle of current pointer (Empty list) + */ +TEST_F(VCTest, utc_vc_cmd_list_get_current_n2) +{ + vc_cmd_list_h list = nullptr; + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_list_get_current(list, &cmd), VC_ERROR_NOT_SUPPORTED); + return; } + + EXPECT_EQ(vc_cmd_list_create(&list), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_list_get_current(list, &cmd), VC_ERROR_EMPTY); + + EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE); } /** @@ -2864,21 +3544,20 @@ TEST_F(VCTest, vc_cmd_destroy_p) * @since_tizen 2.4 * @description Negative UTC for destroy command handle (Invalid parameter) */ -TEST_F(VCTest, vc_cmd_destroy_n) +TEST_F(VCTest, utc_vc_cmd_destroy_n) { + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_destroy(nullptr), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_destroy(NULL); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_destroy(nullptr), VC_ERROR_INVALID_PARAMETER); - int ret = VC_ERROR_NONE; - ret = vc_cmd_destroy(NULL); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_INVALID_PARAMETER); } /** @@ -2906,6 +3585,9 @@ TEST_F(VCTest, vc_cmd_set_command_p) ret = vc_cmd_set_command(cmd, "voice"); EXPECT_EQ(ret, VC_ERROR_NONE); + ret = vc_cmd_set_command(cmd, "voice"); + EXPECT_EQ(ret, VC_ERROR_NONE); + vc_cmd_destroy(cmd); } } @@ -2937,41 +3619,27 @@ TEST_F(VCTest, vc_cmd_set_command_n) * @since_tizen 2.4 * @description Positive UTC for get command text in handle */ -TEST_F(VCTest, vc_cmd_get_command_p) +TEST_F(VCTest, utc_vc_cmd_get_command_p) { + const char *command_text = "voice"; + vc_cmd_h cmd = nullptr; + char *text = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - char *text = NULL; - ret = vc_cmd_get_command(cmd, &text); - if (NULL != text) { - free(text); - text = NULL; - } - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_get_command(cmd, &text), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - ret = vc_cmd_create(&cmd); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_command(cmd, &text), VC_ERROR_NONE); + EXPECT_EQ(text, nullptr); - ret = vc_cmd_set_command(cmd, "voice"); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_command(cmd, command_text), VC_ERROR_NONE); - char *text = NULL; - ret = vc_cmd_get_command(cmd, &text); - if (NULL != text) { - free(text); - text = NULL; - } - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_command(cmd, &text), VC_ERROR_NONE); + EXPECT_STREQ(text, command_text); + free(text); - vc_cmd_destroy(cmd); - } + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -2996,6 +3664,50 @@ TEST_F(VCTest, vc_cmd_get_command_n) } } +/** + * @testcase utc_vc_cmd_set_unfixed_command_p + * @since_tizen 2.4 + * @description Positive UTC for setting the unfixed command text in handle + */ +TEST_F(VCTest, utc_vc_cmd_set_unfixed_command_p) +{ + const char *command_text = "voice"; + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, command_text), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, command_text), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, command_text), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_set_unfixed_command_n + * @since_tizen 2.4 + * @description Negative UTC for setting the unfixed command text in handle (Invalid parameter) + */ +TEST_F(VCTest, utc_vc_cmd_set_unfixed_command_n) +{ + const char *command_text = "voice"; + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_unfixed_command(nullptr, command_text), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_unfixed_command(nullptr, command_text), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, nullptr), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + /** * @testcase utc_vc_cmd_get_unfixed_command_p * @since_tizen 3.0 @@ -3003,39 +3715,25 @@ TEST_F(VCTest, vc_cmd_get_command_n) */ TEST_F(VCTest, vc_cmd_get_unfixed_command_p) { + const char *command_text = "voice"; + vc_cmd_h cmd = nullptr; + char *text = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - char *text = NULL; - ret = vc_cmd_create(&cmd); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_get_unfixed_command(cmd, &text), VC_ERROR_NOT_SUPPORTED); + return; + } - ret = vc_cmd_get_unfixed_command(cmd, &text); - if (NULL != text) { - free(text); - text = NULL; - } - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_unfixed_command(cmd, &text), VC_ERROR_NONE); + EXPECT_EQ(text, nullptr); - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - ret = vc_cmd_create(&cmd); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_unfixed_command(cmd, command_text), VC_ERROR_NONE); - char *text = NULL; - ret = vc_cmd_get_unfixed_command(cmd, &text); - if (NULL != text) { - free(text); - text = NULL; - } - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_unfixed_command(cmd, &text), VC_ERROR_NONE); + EXPECT_STREQ(text, command_text); + free(text); - vc_cmd_destroy(cmd); - } + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -3094,21 +3792,21 @@ TEST_F(VCTest, vc_cmd_set_type_p) * @since_tizen 2.4 * @description Negative UTC for set command type in handle (Invalid parameter) */ -TEST_F(VCTest, vc_cmd_set_type_n) +TEST_F(VCTest, utc_vc_cmd_set_type_n) { + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_set_type(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_set_type(cmd, -1), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_set_type(NULL, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_set_type(NULL, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } + EXPECT_EQ(vc_cmd_set_type(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_set_type(cmd, -1), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -3116,33 +3814,22 @@ TEST_F(VCTest, vc_cmd_set_type_n) * @since_tizen 2.4 * @description Positive UTC for get command type in handle */ -TEST_F(VCTest, vc_cmd_get_type_p) +TEST_F(VCTest, utc_vc_cmd_get_type_p) { + vc_cmd_h cmd = nullptr; + int type = -1; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - int type; - ret = vc_cmd_get_type(cmd, &type); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - ret = vc_cmd_create(&cmd); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_type(cmd, &type), VC_ERROR_NOT_SUPPORTED); + return; + } - ret = vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int type; - ret = vc_cmd_get_type(cmd, &type); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_type(cmd, &type), VC_ERROR_NONE); + EXPECT_EQ(type, VC_COMMAND_TYPE_BACKGROUND); - vc_cmd_destroy(cmd); - } + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -3206,21 +3893,21 @@ TEST_F(VCTest, vc_cmd_set_format_p) * @since_tizen 3.0 * @description Negative UTC for setting command format in handle (Invalid parameter) */ -TEST_F(VCTest, vc_cmd_set_format_n) +TEST_F(VCTest, utc_vc_cmd_set_format_n) { + vc_cmd_h cmd = nullptr; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); + EXPECT_EQ(vc_cmd_set_format(nullptr, VC_COMMAND_FORMAT_FIXED), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_set_format(cmd, -1), VC_ERROR_NOT_SUPPORTED); + return; + } - int ret = VC_ERROR_NONE; - ret = vc_cmd_set_format(NULL, VC_COMMAND_FORMAT_FIXED); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int ret = VC_ERROR_NONE; - ret = vc_cmd_set_format(NULL, VC_COMMAND_FORMAT_FIXED); - EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER); - } + EXPECT_EQ(vc_cmd_set_format(nullptr, VC_COMMAND_FORMAT_FIXED), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_set_format(cmd, -1), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -3228,33 +3915,22 @@ TEST_F(VCTest, vc_cmd_set_format_n) * @since_tizen 3.0 * @description Positive UTC for getting command format in handle */ -TEST_F(VCTest, vc_cmd_get_format_p) +TEST_F(VCTest, utc_vc_cmd_get_format_p) { + vc_cmd_h cmd = nullptr; + int type = -1; if (false == g_vc_supported) { - EXPECT_EQ(g_vc_init, false); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - int format; - ret = vc_cmd_get_format(cmd, &format); - EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED); - } else { - EXPECT_EQ(g_vc_init, true); - - int ret = VC_ERROR_NONE; - vc_cmd_h cmd = NULL; - ret = vc_cmd_create(&cmd); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_format(cmd, &type), VC_ERROR_NOT_SUPPORTED); + return; + } - ret = vc_cmd_set_format(cmd, VC_COMMAND_FORMAT_FIXED); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); - int format; - ret = vc_cmd_get_format(cmd, &format); - EXPECT_EQ(ret, VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_set_format(cmd, VC_CMD_FORMAT_FIXED_AND_NONFIXED), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_format(cmd, &type), VC_ERROR_NONE); + EXPECT_EQ(type, VC_CMD_FORMAT_FIXED_AND_NONFIXED); - vc_cmd_destroy(cmd); - } + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); } /** @@ -3279,4 +3955,180 @@ TEST_F(VCTest, vc_cmd_get_format_n) } } +/** + * @testcase utc_vc_cmd_set_pid_p + * @since_tizen 3.0 + * @description Positive UTC for setting pid in handle + */ +TEST_F(VCTest, utc_vc_cmd_set_pid_p) +{ + vc_cmd_h cmd = nullptr; + int pid = getpid(); + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_pid(cmd, pid), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_pid(cmd, pid), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_set_pid_n + * @since_tizen 3.0 + * @description Negative UTC for setting pid in handle (Invalid handle) + */ +TEST_F(VCTest, utc_vc_cmd_set_pid_n) +{ + vc_cmd_h cmd = nullptr; + int pid = getpid(); + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_pid(nullptr, pid), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_set_pid(cmd, -1), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_pid(nullptr, pid), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_set_pid(cmd, -1), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_get_pid_p + * @since_tizen 3.0 + * @description Positive UTC for getting pid format in handle + */ +TEST_F(VCTest, utc_vc_cmd_get_pid_p) +{ + vc_cmd_h cmd = nullptr; + int pid = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_get_pid(cmd, &pid), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_pid(cmd, getpid()), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_pid(cmd, &pid), VC_ERROR_NONE); + EXPECT_EQ(pid, getpid()); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_get_pid_n + * @since_tizen 3.0 + * @description Positive UTC for getting pid format in handle + */ +TEST_F(VCTest, utc_vc_cmd_get_pid_n) +{ + vc_cmd_h cmd = nullptr; + int pid = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_get_pid(nullptr, &pid), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_get_pid(cmd, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_get_pid(nullptr, &pid), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_get_pid(cmd, nullptr), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_set_domain_p + * @since_tizen 3.0 + * @description Positive UTC for setting command domain in handle + */ +TEST_F(VCTest, utc_vc_cmd_set_domain_p) +{ + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_domain(cmd, 1), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_domain(cmd, 1), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_set_domain_n + * @since_tizen 3.0 + * @description Negative UTC for setting command domain in handle (Invalid parameter) + */ +TEST_F(VCTest, utc_vc_cmd_set_domain_n) +{ + vc_cmd_h cmd = nullptr; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_set_domain(nullptr, 1), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_domain(nullptr, 1), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_get_domain_p + * @since_tizen 3.0 + * @description Positive UTC for getting command domain in handle + */ +TEST_F(VCTest, utc_vc_cmd_get_domain_p) +{ + vc_cmd_h cmd = nullptr; + int domain = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_get_domain(cmd, &domain), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_set_domain(cmd, 1), VC_ERROR_NONE); + EXPECT_EQ(vc_cmd_get_domain(cmd, &domain), VC_ERROR_NONE); + EXPECT_EQ(domain, 1); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + +/** + * @testcase utc_vc_cmd_get_domain_n + * @since_tizen 3.0 + * @description Negative UTC for getting command domain in handle (Invalid parameter) + */ +TEST_F(VCTest, utc_vc_cmd_get_domain_n) +{ + vc_cmd_h cmd = nullptr; + int domain = -1; + if (false == g_vc_supported) { + EXPECT_EQ(vc_cmd_get_domain(nullptr, &domain), VC_ERROR_NOT_SUPPORTED); + EXPECT_EQ(vc_cmd_get_domain(cmd, nullptr), VC_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(vc_cmd_create(&cmd), VC_ERROR_NONE); + + EXPECT_EQ(vc_cmd_get_domain(nullptr, &domain), VC_ERROR_INVALID_PARAMETER); + EXPECT_EQ(vc_cmd_get_domain(cmd, nullptr), VC_ERROR_INVALID_PARAMETER); + + EXPECT_EQ(vc_cmd_destroy(cmd), VC_ERROR_NONE); +} + } // namespace -- 2.34.1