--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <Ecore.h>
+#include <system_info.h>
+
+#include <voice_control.h>
+#include "system_info_mock.h"
+#include "cynara_mock.h"
+
+static int g_vc_init = false;
+static vc_state_e g_vc_state = VC_STATE_NONE;
+static bool g_vc_supported = false;
+
+static void __vc_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, 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_state_changed_cb(vc_state_e previous, vc_state_e current, void* user_data)
+{
+ g_vc_state = current;
+}
+
+static void __vc_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)
+{
+}
+
+static bool __vc_cmd_list_cb(vc_cmd_h vc_command, void* user_data)
+{
+ return true;
+}
+
+namespace {
+
+class VCTest : public testing::Test {
+ public:
+ virtual void SetUp() {
+ ecore_init();
+ ecore_main_loop_glib_integrate();
+
+ cynara_check_set_result(CYNARA_API_ACCESS_ALLOWED);
+
+ g_vc_supported = false;
+ bool mic_supported = false;
+ bool vc_supported = false;
+ if (0 == system_info_get_platform_bool("http://tizen.org/feature/speech.control", &vc_supported))
+ {
+ if (0 == system_info_get_platform_bool("http://tizen.org/feature/microphone", &mic_supported))
+ {
+ if (true == vc_supported && true == mic_supported)
+ {
+ g_vc_supported = true;
+ }
+ }
+ }
+
+ g_vc_init = false;
+ if (true == g_vc_supported)
+ {
+ int ret = VC_ERROR_NONE;
+ ret = vc_initialize();
+ if (VC_ERROR_NONE == ret)
+ {
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, NULL);
+ if (VC_ERROR_NONE != ret)
+ {
+ g_vc_init = false;
+ }
+ else
+ {
+ g_vc_init = true;
+ }
+ }
+ else
+ {
+ g_vc_init = false;
+ }
+ }
+ }
+
+ virtual void TearDown()
+ {
+ if (true == g_vc_supported)
+ {
+ vc_unset_state_changed_cb();
+
+ vc_deinitialize();
+ }
+
+ g_vc_init = false;
+
+ ecore_shutdown();
+ }
+};
+
+TEST_F(VCTest, utc_vc_initialize_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_deinitialize_p
+ * @since_tizen 2.4
+ * @description Positive UTC for deinitialize voice control handle
+ */
+TEST_F(VCTest, vc_deinitialize_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_deinitialize();
+ 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);
+ }
+}
+
+/**
+ * @testcase utc_vc_deinitialize_n
+ * @since_tizen 2.4
+ * @description Negative UTC for deinitialize voice control handle (Already deinitialized)
+ */
+TEST_F(VCTest, vc_deinitialize_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_deinitialize();
+ 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);
+
+ ret = vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_prepare_p
+ * @since_tizen 2.4
+ * @description Positive UTC for connect service daemon
+ */
+TEST_F(VCTest, vc_prepare_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_prepare();
+ 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();
+ }
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_prepare_n
+ * @since_tizen 2.4
+ * @description Negative UTC for connect service daemon (Invalid state)
+ */
+TEST_F(VCTest, vc_prepare_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_prepare();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unprepare_p
+ * @since_tizen 2.4
+ * @description Positive UTC for disconnect service daemon
+ */
+TEST_F(VCTest, vc_unprepare_p)
+{
+ 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_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unprepare_n
+ * @since_tizen 2.4
+ * @description Negative UTC for disconnect service daemon (Invalid state)
+ */
+TEST_F(VCTest, 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);
+ }
+}
+
+/**
+ * @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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_foreach_supported_languages_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get supported language list
+ */
+TEST_F(VCTest, vc_foreach_supported_languages_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_foreach_supported_languages(__vc_supported_language_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_foreach_supported_languages(__vc_supported_language_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_foreach_supported_languages_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get supported language list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_foreach_supported_languages_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_foreach_supported_languages(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_foreach_supported_languages(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_foreach_supported_languages_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for get supported language list (Invalid state)
+ */
+TEST_F(VCTest, vc_foreach_supported_languages_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_foreach_supported_languages(__vc_supported_language_cb, NULL);
+ 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);
+
+ ret = vc_foreach_supported_languages(__vc_supported_language_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_current_language_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get current language
+ */
+TEST_F(VCTest, vc_get_current_language_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ char *lang = NULL;
+ ret = vc_get_current_language(&lang);
+ if (NULL != lang) {
+ free(lang);
+ lang = NULL;
+ }
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ char *lang = NULL;
+ ret = vc_get_current_language(&lang);
+ if (NULL != lang) {
+ free(lang);
+ lang = NULL;
+ }
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_current_language_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get current language (Invalid parameter)
+ */
+TEST_F(VCTest, vc_get_current_language_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_current_language(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_current_language(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_current_language_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for get current language (Invalid state)
+ */
+TEST_F(VCTest, vc_get_current_language_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ char *lang = NULL;
+ ret = vc_get_current_language(&lang);
+ if (NULL != lang) {
+ free(lang);
+ lang = NULL;
+ }
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ char *lang = NULL;
+ ret = vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_get_current_language(&lang);
+ if (NULL != lang) {
+ free(lang);
+ lang = NULL;
+ }
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_state_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get current state
+ */
+TEST_F(VCTest, vc_get_state_p)
+{
+ 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);
+ }
+}
+
+/**
+ * @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);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ vc_state_e state = VC_STATE_NONE;
+ ret = vc_get_state(&state);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_state_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get current state (Invalid parameter)
+ */
+TEST_F(VCTest, vc_get_state_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_state(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_state(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_state_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for get current state (Invalid state)
+ */
+TEST_F(VCTest, vc_get_state_n2)
+{
+ 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_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_state_e state = VC_STATE_NONE;
+ ret = vc_get_state(&state);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_service_state_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get current state of service daemon
+ */
+TEST_F(VCTest, vc_get_service_state_p)
+{
+ 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);
+ 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);
+ }
+}
+
+/**
+ * @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)
+{
+ 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);
+ 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_service_state_e state = VC_SERVICE_STATE_NONE;
+ ret = vc_get_service_state(&state);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_system_command_list_p
+ * @since_tizen 3.0
+ * @description Positive UTC for get the system command list
+ */
+TEST_F(VCTest, vc_get_system_command_list_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_get_system_command_list(&list);
+ 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_cmd_list_h list = NULL;
+ ret = vc_get_system_command_list(&list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_system_command_list_n
+ * @since_tizen 3.0
+ * @description Negative UTC for get the system command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_get_system_command_list_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_system_command_list(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_system_command_list(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_system_command_list_n2
+ * @since_tizen 3.0
+ * @description Negative UTC for get the system command list (Invalid state)
+ */
+TEST_F(VCTest, vc_get_system_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_get_system_command_list(&list);
+ 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_get_system_command_list(&list);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_command_list_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set command list used as candidate set
+ */
+TEST_F(VCTest, vc_set_command_list_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_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_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ vc_cmd_list_h list = NULL;
+ ret = vc_cmd_list_create(&list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_command(cmd, "voice");
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_destroy(list, true);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_command_list_n
+ * @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)
+{
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_command_list(NULL, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_command_list_n2
+ * @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)
+{
+ 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);
+ }
+}
+
+/**
+ * @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);
+
+ 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);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_command_list_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset command list used as candidate set
+ */
+TEST_F(VCTest, vc_unset_command_list_p)
+{
+ 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_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ vc_cmd_list_h list = NULL;
+ ret = vc_cmd_list_create(&list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_command(cmd, "voice");
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_command_list(list, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_destroy(list, true);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_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_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);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_command_list_n2
+ * @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)
+{
+ 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_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_command_list(VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_result_p
+ * @since_tizen 3.0
+ * @description Positive UTC for getting the recognition result
+ */
+TEST_F(VCTest, vc_get_result_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_result(__vc_result_cb, 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();
+ }
+
+ ret = vc_get_result(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_get_result_n
+ * @since_tizen 3.0
+ * @description Negative UTC for getting the recognition result (Invalid parameter)
+ */
+TEST_F(VCTest, vc_get_result_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_get_result(NULL, 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();
+ }
+
+ ret = vc_get_result(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_result_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set result callback
+ */
+TEST_F(VCTest, vc_set_result_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_result_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set result callback (Invalid parameter)
+ */
+TEST_F(VCTest, vc_set_result_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_result_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for set result callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_result_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ 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);
+
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_result_cb_n3
+ * @since_tizen 2.4
+ * @description Negative UTC for set result callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_result_cb_n3)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(__vc_result_cb, 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();
+ }
+
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_result_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset result callback
+ */
+TEST_F(VCTest, vc_unset_result_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_result_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_result_cb(__vc_result_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_result_cb();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_result_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for unset result callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_result_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_result_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_result_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_result_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for unset result callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_result_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_result_cb();
+ 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();
+ }
+
+ ret = vc_unset_result_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_service_state_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set service state changed callback
+ */
+TEST_F(VCTest, vc_set_service_state_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+
+
+}
+
+/**
+ * @testcase utc_vc_set_service_state_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set service state changed callback (Invalid parameter)
+ */
+TEST_F(VCTest, vc_set_service_state_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_service_state_changed_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for set service state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_service_state_changed_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_service_state_changed_cb_n3
+ * @since_tizen 2.4
+ * @description Nagative UTC for set service state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_service_state_changed_cb_n3)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, 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();
+ }
+
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_service_state_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset service state changed callback
+ */
+TEST_F(VCTest, vc_unset_service_state_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_service_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_service_state_changed_cb(__vc_service_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_service_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_service_state_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for unset service state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_service_state_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_service_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_service_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_service_state_changed_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for unset service state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_service_state_changed_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_service_state_changed_cb();
+ 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();
+ }
+
+ ret = vc_unset_service_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_state_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set state changed callback
+ */
+TEST_F(VCTest, vc_set_state_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_state_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set state changed callback (Invalid parameter)
+ */
+TEST_F(VCTest, vc_set_state_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_state_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_state_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_state_changed_cb_n2
+ * @since_tizen 2.4
+ * @description Nagative UTC for set state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_state_changed_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_state_changed_cb_n3
+ * @since_tizen 2.4
+ * @description Negative UTC for set state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_state_changed_cb_n3)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, 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();
+ }
+
+ ret = vc_set_state_changed_cb(__vc_state_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_state_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset state changed callback
+ */
+TEST_F(VCTest, vc_unset_state_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_state_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for unset state changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_state_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_state_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_current_language_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set current language changed callback
+ */
+TEST_F(VCTest, vc_set_current_language_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_current_language_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set current language changed callback (invalid parameter)
+ */
+TEST_F(VCTest, vc_set_current_language_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_current_language_changed_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for set current language changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_current_language_changed_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, 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();
+ }
+
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_current_language_changed_cb_n3
+ * @since_tizen 2.4
+ * @description Negative UTC for set current language changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_current_language_changed_cb_n3)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_current_language_changed_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset current language changed callback
+ */
+TEST_F(VCTest, vc_unset_current_language_changed_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_current_language_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_current_language_changed_cb(__vc_current_language_changed_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_current_language_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_current_language_changed_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for unset current language changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_current_language_changed_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_current_language_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_current_language_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_current_language_changed_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for unset current language changed callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_current_language_changed_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_current_language_changed_cb();
+ 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();
+ }
+
+ ret = vc_unset_current_language_changed_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_error_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set error callback
+ */
+TEST_F(VCTest, vc_set_error_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_error_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set error callback (Invalid parameter)
+ */
+TEST_F(VCTest, vc_set_error_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_error_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for set error callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_error_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ vc_deinitialize();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_error_cb_n3
+ * @since_tizen 2.4
+ * @description Negative UTC for set error callback (Invalid state)
+ */
+TEST_F(VCTest, vc_set_error_cb_n3)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(__vc_error_cb, 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();
+ }
+
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_error_cb_p
+ * @since_tizen 2.4
+ * @description Positive UTC for unset error callback
+ */
+TEST_F(VCTest, vc_unset_error_cb_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_error_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_set_error_cb(__vc_error_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unset_error_cb();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_error_cb_n
+ * @since_tizen 2.4
+ * @description Negative UTC for unset error callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_error_cb_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_error_cb();
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_error_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_unset_error_cb_n2
+ * @since_tizen 2.4
+ * @description Negative UTC for unset error callback (Invalid state)
+ */
+TEST_F(VCTest, vc_unset_error_cb_n2)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_unset_error_cb();
+ 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();
+ }
+
+ ret = vc_unset_error_cb();
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_invocation_name_p
+ * @since_tizen 3.0
+ * @description Positive UTC for setting the invocation name
+ */
+TEST_F(VCTest, vc_set_invocation_name_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ const char* invoc_name = "testapp";
+ ret = vc_set_invocation_name(invoc_name);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ const char* invoc_name = "testapp";
+
+ ret = vc_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = vc_set_invocation_name(invoc_name);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_set_invocation_name_n
+ * @since_tizen 3.0
+ * @description Negative UTC for setting the invocation name (Invalid state)
+ */
+TEST_F(VCTest, vc_set_invocation_name_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ const char* invoc_name = "testapp";
+ ret = vc_set_invocation_name(invoc_name);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ const char* invoc_name = "testapp";
+
+ ret = vc_set_invocation_name(invoc_name);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @testcase utc_vc_request_dialog_p
+ * @since_tizen 3.0
+ * @description Positive UTC for requesting the dialog
+ */
+TEST_F(VCTest, vc_request_dialog_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ const char* disp_txt = "test";
+ const char* utt_txt = "test";
+ bool is_auto_start = true;
+ ret = vc_request_dialog(disp_txt, utt_txt, is_auto_start);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ const char* disp_txt = "test";
+ const char* utt_txt = "test";
+ bool is_auto_start = true;
+
+ ret = vc_prepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ while (VC_STATE_READY != g_vc_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = vc_request_dialog(disp_txt, utt_txt, is_auto_start);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_unprepare();
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_request_dialog_n
+ * @since_tizen 3.0
+ * @description Negative UTC for requesting the dialog (Invalid state)
+ */
+TEST_F(VCTest, vc_request_dialog_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ const char* disp_txt = "voice control test";
+ const char* utt_txt = "This is a test for requesting the dialog";
+ bool is_auto_start = true;
+ ret = vc_request_dialog(disp_txt, utt_txt, is_auto_start);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ vc_deinitialize();
+
+ int ret = VC_ERROR_NONE;
+ const char* disp_txt = "voice control test";
+ const char* utt_txt = "This is a test for requesting the dialog";
+ bool is_auto_start = true;
+ ret = vc_request_dialog(disp_txt, utt_txt, is_auto_start);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_STATE);
+ }
+}
+
+/**
+ * @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;
+ 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);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_create_n
+ * @since_tizen 2.4
+ * @description Negative UTC for create command list handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_create_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ 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;
+ ret = vc_cmd_list_create(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @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)
+{
+ 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);
+ 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_destroy(list, false);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_destroy_n
+ * @since_tizen 2.4
+ * @description Negative UTC for destroy command list handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_destroy_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_destroy(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_destroy(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_get_count_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get count of command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_get_count_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_list_h list = NULL;
+ ret = vc_cmd_list_create(&list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ int cnt = -1;
+ ret = vc_cmd_list_get_count(list, &cnt);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, false);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_get_count_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get count of command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_get_count_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_get_count(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_add_p
+ * @since_tizen 2.4
+ * @description Positive UTC for add command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_add_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_list_h list = NULL;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_list_add(list, cmd);
+ 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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_add_n
+ * @since_tizen 2.4
+ * @description Negative UTC for add command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_add_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_add(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_remove_p
+ * @since_tizen 2.4
+ * @description Positive UTC for remove command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_remove_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_list_h list = NULL;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_list_remove(list, cmd);
+ 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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_remove(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_remove_n
+ * @since_tizen 2.4
+ * @description Negative UTC for remove command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_remove_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_remove(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_foreach_commands_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get whole command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_foreach_commands_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_foreach_commands(list, __vc_cmd_list_cb, 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);
+
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_foreach_commands(list, __vc_cmd_list_cb, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_foreach_commands_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get whole command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_foreach_commands_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_foreach_commands(NULL, NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_first_p
+ * @since_tizen 2.4
+ * @description Positive UTC for move pointer to the first of command list
+ */
+TEST_F(VCTest, vc_cmd_list_first_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_first(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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_first(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_first_n
+ * @since_tizen 2.4
+ * @description Negative UTC for move pointer to the first of command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_first_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_first(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_first(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_last_p
+ * @since_tizen 2.4
+ * @description Positive UTC for move pointer to the last of command list
+ */
+TEST_F(VCTest, vc_cmd_list_last_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_last(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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_last(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_last_n
+ * @since_tizen 2.4
+ * @description Negative UTC for move pointer to the last of command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_last_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_last(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_last(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_next_p
+ * @since_tizen 2.4
+ * @description Positive UTC for move pointer to next command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_next_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_next(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_h cmd = NULL;
+ int i;
+ for (i = 0; i < 2; i++) {
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+
+ ret = vc_cmd_list_first(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_next(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_next_n
+ * @since_tizen 2.4
+ * @description Negative UTC for move pointer to next command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_next_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_next(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_next(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_prev_p
+ * @since_tizen 2.4
+ * @description Positive UTC for move pointer to previous command in command list
+ */
+TEST_F(VCTest, vc_cmd_list_prev_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_prev(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_h cmd = NULL;
+ int i;
+ for (i = 0; i < 2; i++) {
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+
+ ret = vc_cmd_list_last(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_prev(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_prev_n
+ * @since_tizen 2.4
+ * @description Negative UTC for move pointer to previous command in command list (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_prev_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_prev(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_prev(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_get_current_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get command handle of current pointer
+ */
+TEST_F(VCTest, vc_cmd_list_get_current_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_list_h list = NULL;
+ vc_cmd_h cur = NULL;
+ ret = vc_cmd_list_get_current(list, &cur);
+ 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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_add(list, cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_list_first(list);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_h cur = NULL;
+ ret = vc_cmd_list_get_current(list, &cur);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_list_destroy(list, true);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_list_get_current_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get command handle of current pointer (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_list_get_current_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_list_get_current(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_create_p
+ * @since_tizen 2.4
+ * @description Positive UTC for create command handle
+ */
+TEST_F(VCTest, vc_cmd_create_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ 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);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_create_n
+ * @since_tizen 2.4
+ * @description Negative UTC for create command handle
+ */
+TEST_F(VCTest, vc_cmd_create_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_create(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_create(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_destroy_p
+ * @since_tizen 2.4
+ * @description Positive UTC for destroy command handle
+ */
+TEST_F(VCTest, vc_cmd_destroy_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_destroy(cmd);
+ 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);
+
+ ret = vc_cmd_destroy(cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_destroy_n
+ * @since_tizen 2.4
+ * @description Negative UTC for destroy command handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_destroy_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_destroy(NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_destroy(NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_command_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set command text in handle
+ */
+TEST_F(VCTest, vc_cmd_set_command_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_set_command(cmd, "voice");
+ 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);
+
+ ret = vc_cmd_set_command(cmd, "voice");
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_command_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set command text in handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_set_command_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_set_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_set_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_command_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get command text in handle
+ */
+TEST_F(VCTest, vc_cmd_get_command_p)
+{
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_command(cmd, "voice");
+ EXPECT_EQ(ret, 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);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_command_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get command text in handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_get_command_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_unfixed_command_p
+ * @since_tizen 3.0
+ * @description Positive UTC for getting the unfixed command text in handle
+ */
+TEST_F(VCTest, vc_cmd_get_unfixed_command_p)
+{
+ 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);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, 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);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_unfixed_command_n
+ * @since_tizen 3.0
+ * @description Negative UTC for getting the unfixed command text in handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_get_unfixed_command_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_unfixed_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_unfixed_command(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_type_p
+ * @since_tizen 2.4
+ * @description Positive UTC for set command type in handle
+ */
+TEST_F(VCTest, vc_cmd_set_type_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_set_type(cmd, 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_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ ret = vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_type_n
+ * @since_tizen 2.4
+ * @description Negative UTC for set command type in handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_set_type_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_set_type(NULL, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_type_p
+ * @since_tizen 2.4
+ * @description Positive UTC for get command type in handle
+ */
+TEST_F(VCTest, vc_cmd_get_type_p)
+{
+ 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);
+
+ ret = vc_cmd_set_type(cmd, VC_COMMAND_TYPE_BACKGROUND);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ int type;
+ ret = vc_cmd_get_type(cmd, &type);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_type_n
+ * @since_tizen 2.4
+ * @description Negative UTC for get command type in handle (invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_get_type_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_type(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_type(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_format_p
+ * @since_tizen 3.0
+ * @description Positive UTC for setting command format in handle
+ */
+TEST_F(VCTest, vc_cmd_set_format_p)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ vc_cmd_h cmd = NULL;
+ ret = vc_cmd_create(&cmd);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+
+ ret = vc_cmd_set_format(cmd, VC_COMMAND_FORMAT_FIXED);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+
+ vc_cmd_destroy(cmd);
+ } 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);
+
+ ret = vc_cmd_set_format(cmd, VC_COMMAND_FORMAT_FIXED);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_set_format_n
+ * @since_tizen 3.0
+ * @description Negative UTC for setting command format in handle (Invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_set_format_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ 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);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_set_format(NULL, VC_COMMAND_FORMAT_FIXED);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_format_p
+ * @since_tizen 3.0
+ * @description Positive UTC for getting command format in handle
+ */
+TEST_F(VCTest, vc_cmd_get_format_p)
+{
+ 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);
+
+ ret = vc_cmd_set_format(cmd, VC_COMMAND_FORMAT_FIXED);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ int format;
+ ret = vc_cmd_get_format(cmd, &format);
+ EXPECT_EQ(ret, VC_ERROR_NONE);
+
+ vc_cmd_destroy(cmd);
+ }
+}
+
+/**
+ * @testcase utc_vc_cmd_get_format_n
+ * @since_tizen 3.0
+ * @description Negative UTC for getting command format in handle(invalid parameter)
+ */
+TEST_F(VCTest, vc_cmd_get_format_n)
+{
+ if (false == g_vc_supported) {
+ EXPECT_EQ(g_vc_init, false);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_format(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_EQ(g_vc_init, true);
+
+ int ret = VC_ERROR_NONE;
+ ret = vc_cmd_get_format(NULL, NULL);
+ EXPECT_EQ(ret, VC_ERROR_INVALID_PARAMETER);
+ }
+}
+
+} // namespace
projects / platform / core / uifw / voice-control.git / commitdiff