--- /dev/null
+/*
+ * 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 <gtest/gtest.h>
+#include <Ecore.h>
+#include <system_info.h>
+#include <tzplatform_config.h>
+
+#include <voice_control_manager.h>
+#include "system_info_mock.h"
+#include "cynara_mock.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 *DEFAULT_ENGINE_APP_ID = "org.tizen.vc-engine-default";
+
+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 __is_mgr_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_mgr_state) {
+ ecore_main_loop_iterate();
+ usleep(100000);
+ count++;
+ }
+
+ if (state != g_vc_mgr_state) {
+ return false;
+ }
+
+ return true;
+}
+
+static bool __is_mgr_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_mgr_service_state) {
+ ecore_main_loop_iterate();
+ usleep(100000);
+ count++;
+ }
+
+ if (state != g_vc_mgr_service_state) {
+ return false;
+ }
+
+ return true;
+}
+
+static void __vc_mgr_specific_engine_result_cb(const char* engine_app_id, const char* event, const char* result, void *user_data)
+{
+}
+
+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_mgr_pre_result_cb(vc_pre_result_event_e event, const char *result, void *user_data)
+{
+}
+
+static void __vc_mgr_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, void* user_data)
+{
+}
+
+static void __vc_mgr_begin_speech_detected_cb(void *user_data)
+{
+}
+
+static void __vc_mgr_dialog_request_cb(int pid, const char *disp_text, const char *utt_text, bool continuous, void *user_data)
+{
+}
+
+static int __vc_mgr_private_data_set_cb(const char *key, const char *data, void *user_data)
+{
+ return 0;
+}
+
+static int __vc_mgr_private_data_requested_cb(const char *key, char **data, void *user_data)
+{
+ return 0;
+}
+
+static void __vc_mgr_feedback_audio_format_cb(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type, void *user_data)
+{
+}
+
+static void __vc_mgr_feedback_streaming_cb(vc_feedback_event_e event, char* buffer, int len, void *user_data)
+{
+}
+
+static void __vc_current_language_changed_cb(const char* previous, const char* current, void* user_data)
+{
+}
+
+static bool __vc_supported_language_cb(const char* language, void* user_data)
+{
+ return true;
+}
+
+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 void __vc_mgr_error_cb(vc_error_e reason, void* user_data)
+{
+}
+
+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_SYSTEM), 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_ecore()
+{
+ ecore_init();
+ ecore_main_loop_glib_integrate();
+}
+
+static void __shutdown_ecore()
+{
+ ecore_shutdown();
+}
+
+static bool __is_vc_mgr_supported()
+{
+ bool is_vc_supported = false;
+ bool is_mic_supported = false;
+ if (0 != system_info_get_platform_bool("http://tizen.org/feature/speech.control", &is_vc_supported))
+ {
+ is_vc_supported = false;
+ }
+
+ if (0 != system_info_get_platform_bool("http://tizen.org/feature/microphone", &is_mic_supported))
+ {
+ is_mic_supported = false;
+ }
+
+ if (is_vc_supported && is_mic_supported)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+namespace {
+
+class VcMgrTestInNoneState : public testing::Test {
+ public:
+ virtual void SetUp()
+ {
+ __initialize_ecore();
+ g_vc_mgr_state = VC_STATE_NONE;
+ g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
+ __is_feature_supported = __is_vc_mgr_supported();
+ }
+
+ virtual void TearDown()
+ {
+ vc_mgr_deinitialize();
+ __shutdown_ecore();
+ }
+
+ public:
+ bool __is_feature_supported = false;
+};
+
+/**
+ * @testcase utc_vc_mgr_initialize_p1
+ * @since_tizen 5.0
+ * @description Positive UTC for initialize voice control manager handle
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_initialize_p1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_mgr_initialize_p2
+ * @since_tizen 5.0
+ * @description Positive UTC for initialize voice control manager handle
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_initialize_p2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_mgr_deinitialize_p
+ * @since_tizen 5.0
+ * @description Positive UTC for deinitialize voice control manager handle
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_deinitialize_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_mgr_deinitialize_n
+ * @since_tizen 5.0
+ * @description Negative UTC for deinitialize voice control manager handle
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_deinitialize_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_INVALID_STATE);
+ }
+}
+
+
+class VcMgrTestInInitializedState : public testing::Test {
+ public:
+ virtual void SetUp()
+ {
+ __initialize_ecore();
+ g_vc_mgr_state = VC_STATE_NONE;
+ g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
+ __is_feature_supported = __is_vc_mgr_supported();
+
+ 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);
+ }
+
+ virtual void TearDown()
+ {
+ vc_mgr_unprepare();
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+
+ __shutdown_ecore();
+ }
+
+ public:
+ bool __is_feature_supported = false;
+};
+
+/**
+ * @testcase utc_vc_mgr_prepare_p
+ * @since_tizen 5.0
+ * @description Positive UTC for connect service daemon
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_prepare_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
+ ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
+}
+
+/**
+ * @testcase utc_vc_mgr_prepare_n
+ * @since_tizen 5.0
+ * @description Negative UTC for connect service daemon
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_prepare_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
+ ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
+
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unprepare_p
+ * @since_tizen 5.0
+ * @description Positive UTC for disconnect service daemon
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
+ ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
+
+ EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unprepare_n
+ * @since_tizen 5.0
+ * @description Negative UTC for disconnect service daemon
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_foreach_supported_languages_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get supported language list
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_foreach_supported_languages_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_foreach_supported_languages_n1
+ * @since_tizen 5.0
+ * @description Negatvie UTC for get supported language list
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_foreach_supported_languages_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_foreach_supported_languages_n2
+ * @since_tizen 5.0
+ * @description Negatvie UTC for get supported language list
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_foreach_supported_languages_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_language_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get current language
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_language_p)
+{
+ char *language = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NOT_SUPPORTED);
+ free(language);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NONE);
+ ASSERT_NE(language, nullptr);
+ free(language);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_language_n1
+ * @since_tizen 5.0
+ * @description Negatvie UTC for get current language
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_language_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_language(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_language(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_language_n2
+ * @since_tizen 5.0
+ * @description Negatvie UTC for get current language
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_current_language_n2)
+{
+ char *language = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NOT_SUPPORTED);
+ free(language);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_INVALID_STATE);
+}
+
+
+class VcMgrTestInReadyState : public testing::Test {
+ public:
+ virtual void SetUp()
+ {
+ __initialize_ecore();
+ g_vc_mgr_state = VC_STATE_NONE;
+ g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
+ __is_feature_supported = __is_vc_mgr_supported();
+
+ 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_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));
+ }
+
+ virtual void TearDown()
+ {
+ EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+
+ __shutdown_ecore();
+ }
+
+ public:
+ bool __is_feature_supported = false;
+};
+
+/**
+ * @testcase utc_vc_mgr_get_state_p1
+ * @since_tizen 5.0
+ * @description Positive UTC for get current state
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_state_p1)
+{
+ vc_state_e state;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NONE);
+ EXPECT_EQ(state, VC_STATE_INITIALIZED);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_state_p2
+ * @since_tizen 5.0
+ * @description Positive UTC for get current state
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_state_p2)
+{
+ vc_state_e state;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NONE);
+ EXPECT_EQ(state, VC_STATE_READY);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_state_n
+ * @since_tizen 5.0
+ * @description Negative UTC for get current state
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_state_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_state(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_state(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_state_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get current state
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_state_n2)
+{
+ vc_state_e state;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_service_state_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get current state of service daemon
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_p)
+{
+ vc_service_state_e state;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
+ EXPECT_EQ(state, VC_SERVICE_STATE_READY);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_service_state_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get current state of service daemon
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_service_state(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_service_state(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_service_state_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get current state of service daemon
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_service_state_n2)
+{
+ vc_service_state_e state;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_is_command_format_supported_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get supported command format
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_is_command_format_supported_p)
+{
+ int format = VC_COMMAND_FORMAT_FIXED;
+ bool support = false;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_is_command_format_supported_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get supported command format
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_is_command_format_supported_n1)
+{
+ int format = VC_COMMAND_FORMAT_FIXED;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_is_command_format_supported_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get supported command format
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_is_command_format_supported_n2)
+{
+ int format = VC_COMMAND_FORMAT_FIXED;
+ bool support = false;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set command list used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_p)
+{
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_NE(commands, nullptr);
+
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NOT_SUPPORTED);
+ vc_cmd_list_destroy(commands, true);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set command list used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set command list used as candidate set
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_n2)
+{
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_NE(commands, nullptr);
+
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NOT_SUPPORTED);
+ vc_cmd_list_destroy(commands, true);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_INVALID_STATE);
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_command_list_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset command list used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unset_command_list_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_NE(commands, nullptr);
+
+ EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NONE);
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_command_list_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset command list used as candidate set
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_command_list_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_from_file_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset command list from file used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_from_file_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for unset command list from file used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_from_file_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for unset command list from file used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_from_file_n3
+ * @since_tizen 5.0
+ * @description Negative UTC for unset command list from file used as candidate set
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n3)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_preloaded_commands_from_file_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set preloaded commands from file used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_preloaded_commands_from_file_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_preloaded_commands_from_file_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set preloaded commands from file used as candidate set
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_preloaded_commands_from_file_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_command_list_from_file_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for unset command list from file used as candidate set
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_commands_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get command handle of current pointer
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_current_commands_p)
+{
+ vc_cmd_list_h commands = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_commands_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get command handle of current pointer
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_current_commands_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_commands(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_commands(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_current_commands_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get command handle of current pointer
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_commands_n2)
+{
+ vc_cmd_list_h commands = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_audio_type_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set audio type
+ */
+TEST_F(VcMgrTestInReadyState, vc_set_result_cb_p)
+{
+ const char *audioType = "audio_id";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_audio_type_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set audio type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_audio_type_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_audio_type(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_audio_type(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_audio_type_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set audio type
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_type_n2)
+{
+ const char *audioType = "audio_id";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_audio_type_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get audio type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_audio_type_p)
+{
+ char *audioType = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NOT_SUPPORTED);
+ free(audioType);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NONE);
+ free(audioType);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_audio_type_n1
+ * @since_tizen 5.0
+ * @description Positive UTC for get audio type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_audio_type_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_audio_type(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_audio_type(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_audio_type_n2
+ * @since_tizen 5.0
+ * @description Positive UTC for get audio type
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_audio_type_n2)
+{
+ char *audioType = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NOT_SUPPORTED);
+ free(audioType);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_INVALID_STATE);
+ free(audioType);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_recognition_mode_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set recognition mode
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_recognition_mode_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_recognition_mode_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set recognition mode
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_recognition_mode_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_recognition_mode(static_cast<vc_recognition_mode_e>(-1)), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_recognition_mode(static_cast<vc_recognition_mode_e>(-1)), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_recognition_mode_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set recognition mode
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_recognition_mode_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recognition_mode_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get recognition mode
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recognition_mode_p)
+{
+ vc_recognition_mode_e mode = VC_RECOGNITION_MODE_MANUAL;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NONE);
+ EXPECT_EQ(mode, VC_RECOGNITION_MODE_STOP_BY_SILENCE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recognition_mode_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get recognition mode
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recognition_mode_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recognition_mode(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_recognition_mode(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recognition_mode_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get recognition mode
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_recognition_mode_n2)
+{
+ vc_recognition_mode_e mode = VC_RECOGNITION_MODE_MANUAL;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set private data
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_private_data_p)
+{
+ const char *key = "key";
+ const char *data = "data";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NOT_SUPPORTED);
+ EXPECT_EQ(vc_mgr_set_private_data(key, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_set_private_data(key, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_private_data_n1)
+{
+ const char *data = "data";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data(nullptr, data), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data(nullptr, data), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_n2)
+{
+ const char *key = "key";
+ const char *data = "data";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_private_data_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get private data
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_private_data_p)
+{
+ const char *key = "key";
+ char *data = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NOT_SUPPORTED);
+ free(data);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NONE);
+ free(data);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_private_data_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get private data
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_private_data_n1)
+{
+ const char *key = "key";
+ char *data = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_private_data(nullptr, &data), VC_ERROR_NOT_SUPPORTED);
+ EXPECT_EQ(vc_mgr_get_private_data(key, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_private_data(nullptr, &data), VC_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(vc_mgr_get_private_data(key, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_private_data_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get private data
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_private_data_n2)
+{
+ const char *key = "key";
+ char *data = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_do_action_p
+ * @since_tizen 5.0
+ * @description Positive UTC for requesting the do action
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_do_action_p)
+{
+ char *event = strdup("send_event");
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NOT_SUPPORTED);
+ free(event);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NONE);
+ free(event);
+}
+
+/**
+ * @testcase utc_vc_mgr_do_action_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for requesting the do action
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_do_action_n1)
+{
+ char *event = strdup("send_event");
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_do_action(static_cast<vc_send_event_type_e>(-1), event), VC_ERROR_NOT_SUPPORTED);
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, nullptr), VC_ERROR_NOT_SUPPORTED);
+ free(event);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_do_action(static_cast<vc_send_event_type_e>(-1), event), VC_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, nullptr), VC_ERROR_INVALID_PARAMETER);
+ free(event);
+}
+
+/**
+ * @testcase utc_vc_mgr_do_action_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for requesting the do action
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_do_action_n2)
+{
+ char *event = strdup("send_event");
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NOT_SUPPORTED);
+ free(event);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_INVALID_STATE);
+ free(event);
+}
+
+/**
+ * @testcase utc_vc_mgr_send_specific_engine_request_p
+ * @since_tizen 5.0
+ * @description Positive UTC for send specific engine request
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_p)
+{
+ const char* engineAppId = DEFAULT_ENGINE_APP_ID;
+ const char* event = "event";
+ const char* request = "request";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_send_specific_engine_request_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for send specific engine request
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_n1)
+{
+ const char* engineAppId = DEFAULT_ENGINE_APP_ID;
+ const char* event = "event";
+ const char* request = "request";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(nullptr, event, request), VC_ERROR_NOT_SUPPORTED);
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, nullptr, request), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(nullptr, event, request), VC_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, nullptr, request), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_send_specific_engine_request_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for send specific engine request
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_send_specific_engine_request_n2)
+{
+ const char* engineAppId = DEFAULT_ENGINE_APP_ID;
+ const char* event = "event";
+ const char* request = "request";
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_start_p
+ * @since_tizen 5.0
+ * @description Positive UTC for start about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_start_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for start about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_start_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for start about voice control manager
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_start_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_stop_p
+ * @since_tizen 5.0
+ * @description Positive UTC for stop about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_stop_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for stop about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+
+ EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
+
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_stop_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for stop about voice control manager
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_stop_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_cancel_p
+ * @since_tizen 5.0
+ * @description Positive UTC for cancel about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+
+ ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_cancel_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for cancel about voice control manager
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+
+ ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_IN_PROGRESS_TO_READY);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_cancel_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for cancel about voice control manager
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_cancel_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recording_volume_p
+ * @since_tizen 5.0
+ * @description Positive UTC for get recording volume
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_p)
+{
+ float volume = 0.0;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ vc_cmd_list_h commands = __create_test_command_list();
+ ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
+
+ ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
+
+ EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NONE);
+
+ EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+ EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
+
+ vc_cmd_list_destroy(commands, true);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recording_volume_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get recording volume
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recording_volume(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_recording_volume(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_recording_volume_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get recording volume
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_n2)
+{
+ float volume = 0;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_all_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set all result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_all_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_all_result_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set all result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_all_result_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_all_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_all_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_all_result_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set all result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_all_result_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_all_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset all result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_all_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_all_result_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset all result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_all_result_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_pre_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set pre result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_pre_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_pre_result_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set pre result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_pre_result_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_pre_result_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set pre result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_pre_result_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_pre_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset pre result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_pre_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_pre_result_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset pre result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_pre_result_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_specific_engine_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set specific engine result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_specific_engine_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_specific_engine_result_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set specific engine result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_specific_engine_result_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_specific_engine_result_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set specific engine result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_specific_engine_result_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_specific_engine_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset specific engine result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_specific_engine_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_specific_engine_result_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset specific engine result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_specific_engine_result_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_result_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_result_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_result_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_result_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_result_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset result callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_result_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_result_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset result callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_result_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_state_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_state_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_state_changed_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_state_changed_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_state_changed_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set state changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_state_changed_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_state_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_state_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_state_changed_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset state changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_state_changed_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_service_state_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set service state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_service_state_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_service_state_changed_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set service state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_service_state_changed_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_service_state_changed_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set service state changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_service_state_changed_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_service_state_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset service state changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_service_state_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_service_state_changed_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset service state changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_service_state_changed_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_speech_detected_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set speech detected callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_speech_detected_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_speech_detected_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set speech detected callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_speech_detected_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_speech_detected_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set speech detected callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_speech_detected_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_speech_detected_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset speech detected callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_speech_detected_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_speech_detected_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset speech detected callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_speech_detected_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_current_language_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set current language changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_current_language_changed_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set current language changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_current_language_changed_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set current language changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_current_language_changed_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_current_language_changed_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset current language changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_current_language_changed_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_current_language_changed_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset current language changed callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_current_language_changed_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_error_message_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for get error message
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_error_message_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_error_message(nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_error_message(nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_error_message_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for get error message
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_error_message_n2)
+{
+ char *err_msg = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_get_error_message_n3
+ * @since_tizen 5.0
+ * @description Negative UTC for get error message
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_error_message_n3)
+{
+ char *err_msg = nullptr;
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_OPERATION_FAILED);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_error_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set error callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_error_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_error_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set error callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_error_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_error_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_error_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_error_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set error callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_error_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_error_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset error callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_error_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_error_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset error callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_error_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_dialog_request_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set dialog request callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_dialog_request_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_dialog_request_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set dialog request callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_dialog_request_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_dialog_request_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set dialog request callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_dialog_request_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_dialog_request_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset dialog request callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_dialog_request_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_dialog_request_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset dialog request callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_dialog_request_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_enable_command_type_p
+ * @since_tizen 5.0
+ * @description Positive UTC for enable command type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_enable_command_type_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_enable_command_type_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for enable command type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_enable_command_type_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_enable_command_type(-1), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_enable_command_type(-1), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_enable_command_type_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for enable command type
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_enable_command_type_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_disable_command_type_p
+ * @since_tizen 5.0
+ * @description Positive UTC for disable command type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_disable_command_type_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_disable_command_type_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for disable command type
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_disable_command_type_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_disable_command_type(-1), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_disable_command_type(-1), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_disable_command_type_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for disable command type
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_disable_command_type_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_set_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set private data set callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_set_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_set_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data set callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_set_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_set_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data set callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_private_data_set_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_private_data_set_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset private data set callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_private_data_set_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_private_data_set_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset private data set callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_private_data_set_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_requested_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set private data requested callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_requested_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_requested_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data requested callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_requested_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_private_data_requested_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set private data requested callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_private_data_requested_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_private_data_requested_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset private data requested callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_private_data_requested_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_audio_format_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set feedback audio format callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_audio_format_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_audio_format_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set feedback audio format callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_audio_format_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_audio_format_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set feedback audio format callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_audio_format_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_audio_format_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set feedback audio format callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_audio_format_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_feedback_audio_format_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset feedback audio format callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_feedback_audio_format_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_feedback_audio_format_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset feedback audio format callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_feedback_audio_format_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_streaming_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for set feedback streaming callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_streaming_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_streaming_cb_n1
+ * @since_tizen 5.0
+ * @description Negative UTC for set feedback streaming callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_streaming_cb_n1)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase utc_vc_mgr_set_feedback_streaming_cb_n2
+ * @since_tizen 5.0
+ * @description Negative UTC for set feedback streaming callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_streaming_cb_n2)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_feedback_streaming_cb_p
+ * @since_tizen 5.0
+ * @description Positive UTC for unset feedback streaming callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_feedback_streaming_cb_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_unset_feedback_streaming_cb_n
+ * @since_tizen 5.0
+ * @description Negative UTC for unset feedback streaming callback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_feedback_streaming_cb_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase utc_vc_mgr_start_feedback_p
+ * @since_tizen 5.0
+ * @description Positive UTC for start feedback
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_feedback_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_start_feedback_n
+ * @since_tizen 5.0
+ * @description Negative UTC for start feedback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_start_feedback_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_stop_feedback_p
+ * @since_tizen 5.0
+ * @description Negative UTC for stop feedback
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_feedback_p)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase utc_vc_mgr_stop_feedback_n
+ * @since_tizen 5.0
+ * @description Negative UTC for stop feedback
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_stop_feedback_n)
+{
+ if (false == __is_feature_supported) {
+ EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
+ EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_INVALID_STATE);
+ EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
+}
+
+
+} // namespace
projects / platform / core / uifw / voice-control.git / commitdiff