--- /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 <stt.h>
+#include <system_info.h>
+#include "../../client/stt_client.h"
+
+#include "cynara_mock.h"
+#include "system_info_mock.h"
+#include "calloc_mock.h"
+
+namespace {
+
+stt_h g_stt = NULL;
+static char *g_engine_id = NULL;
+static char *g_language = NULL;
+static stt_state_e g_current_state;
+static stt_state_e g_temp_current_state;
+static bool g_stt_supported = false;
+static stt_error_e g_error = STT_ERROR_NONE;
+
+static bool __stt_supported_engine_cb(stt_h stt, const char* engine_id, const char* engine_name, void* user_data)
+{
+ return true;
+}
+
+static bool __stt_supported_language_cb(stt_h stt, const char* lang, void* user_data)
+{
+ return true;
+}
+
+static void __stt_state_changed_cb(stt_h stt, stt_state_e previous, stt_state_e current, void* user_data)
+{
+ g_current_state = current;
+}
+
+static void __stt_temp_state_changed_cb(stt_h stt, stt_state_e previous, stt_state_e current, void* user_data)
+{
+ g_temp_current_state = current;
+}
+
+static void __stt_error_cb(stt_h stt, stt_error_e reason, void *user_data)
+{
+ g_error = reason;
+ printf("ERROR(%d)", g_error);
+
+ return;
+}
+
+static void __stt_recognition_result_cb(stt_h stt, stt_result_event_e event, const char** data, int data_count, const char* msg, void *user_data)
+{
+}
+
+static bool __stt_result_time_cb(stt_h stt, int index, stt_result_time_event_e event, const char* text, long start_time, long end_time, void *user_data)
+{
+ return true;
+}
+
+static void __stt_default_language_changed_cb(stt_h stt, const char* previous, const char* current, void *user_data)
+{
+}
+
+static void __stt_engine_changed_cb(stt_h stt, const char* engine_id, const char* language, bool support_silence, bool need_credential, void *user_data)
+{
+}
+
+static void __stt_speech_status_cb(stt_h stt, stt_speech_status_e status, void *user_data)
+{
+}
+
+class STTTest : public testing::Test {
+ public:
+ virtual void SetUp() {
+ ecore_init();
+
+ cynara_check_set_result(CYNARA_API_ACCESS_ALLOWED);
+
+ /* start of TC */
+ int ret = -1;
+ g_stt_supported = true;
+ system_info_get_platform_bool("http://tizen.org/feature/speech.recognition", &g_stt_supported);
+ g_current_state = STT_STATE_CREATED;
+ g_error = STT_ERROR_NONE;
+
+ if (g_stt_supported) {
+ g_stt = NULL;
+ ret = stt_create(&g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+ }
+ virtual void TearDown() {
+ /* end of TC */
+ int ret = -1;
+ if (true == g_stt_supported) {
+ ret = stt_unset_state_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_unset_error_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_destroy(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+ g_stt = NULL;
+ ecore_shutdown();
+ }
+};
+
+TEST_F(STTTest, utc_stt_create_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ EXPECT_EQ(g_stt, nullptr);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ EXPECT_NE(stt, nullptr);
+
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_create_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_create(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_create(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_destroy_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_destroy(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_create(&g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_destroy_p1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(stt, __stt_temp_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_get_state(stt, &g_temp_current_state);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_temp_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ /* Destroy stt on ready state */
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_destroy_p2)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check to remove timer */
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_destroy_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_destroy_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ stt_h stt = NULL;
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+static int g_n2_state_changed_ret = STT_ERROR_NONE;
+static void __stt_n2_state_changed_cb(stt_h stt, stt_state_e previous, stt_state_e current, void* user_data)
+{
+ g_temp_current_state = current;
+
+ /* Fail to destroy in callback function */
+ g_n2_state_changed_ret = stt_destroy(stt);
+}
+
+TEST_F(STTTest, utc_stt_destroy_n2)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_destroy(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Fail to destroy in callback function */
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(stt, __stt_n2_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_get_state(stt, &g_temp_current_state);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_temp_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ EXPECT_EQ(g_n2_state_changed_ret, STT_ERROR_OPERATION_FAILED);
+
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_prepare_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_prepare_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_prepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_prepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_prepare_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_prepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(stt, __stt_temp_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_get_state(stt, &g_temp_current_state);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_temp_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_prepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ /* Destroy stt on ready state */
+ ret = stt_destroy(stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unprepare_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while(STT_STATE_READY!=g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unprepare_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unprepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unprepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unprepare_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unprepare(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_supported_engines_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_supported_engines(g_stt, __stt_supported_engine_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_foreach_supported_engines(g_stt, __stt_supported_engine_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_supported_engines_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_supported_engines(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_foreach_supported_engines(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_supported_engines_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_supported_engines(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_foreach_supported_engines(g_stt, __stt_supported_engine_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_engine_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_engine(g_stt, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_engine(g_stt, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ if (NULL != g_engine_id) {
+ free(g_engine_id);
+ g_engine_id = NULL;
+ }
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_engine_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_engine(NULL, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_get_engine(NULL, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+
+ if (NULL != g_engine_id) {
+ free(g_engine_id);
+ g_engine_id = NULL;
+ }
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_engine_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_engine(NULL, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_get_engine(g_stt, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ if (NULL != g_engine_id) {
+ free(g_engine_id);
+ g_engine_id = NULL;
+ }
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_engine_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine(g_stt, g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_engine(g_stt, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_engine(g_stt, g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ if (NULL != g_engine_id) {
+ free(g_engine_id);
+ g_engine_id = NULL;
+ }
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_engine_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine(NULL, g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_engine(NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_engine_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine(NULL, g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_engine(g_stt, &g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_engine(g_stt, g_engine_id);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ if (NULL != g_engine_id) {
+ free(g_engine_id);
+ g_engine_id = NULL;
+ }
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_supported_languages_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_supported_languages(g_stt, __stt_supported_language_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_foreach_supported_languages(g_stt, __stt_supported_language_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_supported_languages_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_supported_languages(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_foreach_supported_languages(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_default_language_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_default_language(g_stt, &g_language);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_default_language(g_stt, &g_language);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ if (NULL != g_language) {
+ free(g_language);
+ g_language = NULL;
+ }
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_default_language_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_default_language(NULL, &g_language);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_get_default_language(NULL, &g_language);
+ free (g_language);
+ g_language = NULL;
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_state_p)
+{
+ stt_state_e state;
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_state(g_stt, &state);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_state(g_stt, &state);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_state_n)
+{
+ stt_state_e state;
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_state(NULL, &state);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_get_state(NULL, &state);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_is_recognition_type_supported_p)
+{
+ bool support;
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_is_recognition_type_supported(g_stt, STT_RECOGNITION_TYPE_FREE, &support);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+ ret = stt_is_recognition_type_supported(g_stt, STT_RECOGNITION_TYPE_FREE, &support);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_is_recognition_type_supported_p1)
+{
+ bool support;
+ int ret = STT_ERROR_NONE;
+ const char* type = "STT_RECOGNITION_TYPE_TEST";
+
+ if (false == g_stt_supported) {
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ support = true;
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_is_recognition_type_supported_n)
+{
+ bool support;
+ int ret = STT_ERROR_NONE;
+ const char* type = "STT_RECOGNITION_TYPE_NOT_SUPPORTED";
+
+ if (false == g_stt_supported) {
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_is_recognition_type_supported(NULL, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_is_recognition_type_supported_n1)
+{
+ bool support;
+ int ret = STT_ERROR_NONE;
+ const char* type = "STT_RECOGNITION_TYPE_NOT_SUPPORTED";
+
+ if (false == g_stt_supported) {
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_is_recognition_type_supported_n2)
+{
+ bool support;
+ int ret = STT_ERROR_NONE;
+ const char* type = "STT_RECOGNITION_TYPE_NOT_SUPPORTED";
+
+ if (false == g_stt_supported) {
+ ret = stt_is_recognition_type_supported(g_stt, type, &support);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_is_recognition_type_supported(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_silence_detection_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_silence_detection(g_stt, STT_OPTION_SILENCE_DETECTION_AUTO);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+ ret = stt_set_silence_detection(g_stt, STT_OPTION_SILENCE_DETECTION_AUTO);
+ assert(STT_ERROR_NONE == ret || STT_ERROR_NOT_SUPPORTED_FEATURE == ret);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_silence_detection_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_silence_detection(NULL, STT_OPTION_SILENCE_DETECTION_AUTO);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_silence_detection(NULL, STT_OPTION_SILENCE_DETECTION_AUTO);
+ assert(STT_ERROR_NONE != ret && STT_ERROR_NOT_SUPPORTED_FEATURE != ret);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_silence_detection_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_silence_detection(NULL, STT_OPTION_SILENCE_DETECTION_AUTO);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_silence_detection(g_stt, STT_OPTION_SILENCE_DETECTION_AUTO);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_silence_detection_n2)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_silence_detection(NULL, STT_OPTION_SILENCE_DETECTION_AUTO);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ /* Check invalid parameter */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_silence_detection(g_stt, (stt_option_silence_detection_e)-1);
+ assert(STT_ERROR_INVALID_PARAMETER == ret || STT_ERROR_NOT_SUPPORTED_FEATURE == ret);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_start_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_start(NULL, g_language, STT_RECOGNITION_TYPE_FREE);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_start(g_stt, NULL, STT_RECOGNITION_TYPE_FREE);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_start_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_start(NULL, g_language, STT_RECOGNITION_TYPE_FREE);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ ret = stt_start(NULL, NULL, STT_RECOGNITION_TYPE_FREE);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_stop_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_stop(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_stop(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_cancel_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_cancel(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_cancel(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_cancel_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_cancel(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_cancel(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_recording_volume_n)
+{
+ float vol;
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_recording_volume(NULL, &vol);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_get_recording_volume(NULL, &vol);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_recording_volume_n1)
+{
+ float vol;
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_get_recording_volume(NULL, &vol);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_get_recording_volume(g_stt, &vol);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_recognition_result_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_recognition_result_cb(g_stt, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_recognition_result_cb(g_stt, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_recognition_result_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_recognition_result_cb(NULL, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_recognition_result_cb(NULL, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_recognition_result_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_recognition_result_cb(NULL, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_recognition_result_cb(g_stt, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_recognition_result_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_recognition_result_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_recognition_result_cb(g_stt, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unset_recognition_result_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_recognition_result_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_recognition_result_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_recognition_result_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_recognition_result_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_recognition_result_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_recognition_result_cb(g_stt, __stt_recognition_result_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unset_recognition_result_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_state_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_state_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_state_changed_cb(NULL, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_state_changed_cb(NULL, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_state_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_state_changed_cb(NULL, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_state_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_state_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_unset_state_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_state_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_state_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_state_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_state_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_state_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unset_state_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_error_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_error_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_error_cb(NULL, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_error_cb(NULL, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_error_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_error_cb(NULL, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_error_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_error_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_unset_error_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_error_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_error_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_error_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_error_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_error_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unset_error_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_default_language_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_default_language_changed_cb(g_stt, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_default_language_changed_cb(g_stt, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_default_language_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_default_language_changed_cb(NULL, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_default_language_changed_cb(NULL, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_default_language_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_default_language_changed_cb(NULL, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_default_language_changed_cb(g_stt, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_default_language_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_default_language_changed_cb(g_stt, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_unset_default_language_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_default_language_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_default_language_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_default_language_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_default_language_changed_cb(g_stt, __stt_default_language_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unset_default_language_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_start_sound_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_start_sound_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_start_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_start_sound(NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_start_sound_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_start_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ /* check invalid state */
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_start_sound_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_start_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+ ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unset_start_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_start_sound_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_start_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ EXPECT_NE(STT_STATE_READY, g_current_state);
+
+ ret = stt_unset_start_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_start_sound_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_start_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ EXPECT_NE(STT_STATE_READY, g_current_state);
+
+ ret = stt_unset_start_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_stop_sound_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_stop_sound(g_stt, "test.wav");
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_stop_sound_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_stop_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_stop_sound(NULL, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_stop_sound_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_stop_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ ret = stt_set_stop_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_stop_sound_n2)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_stop_sound(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_stop_sound_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_stop_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unset_stop_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_stop_sound_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_stop_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ EXPECT_NE(STT_STATE_READY, g_current_state);
+
+ ret = stt_unset_stop_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_stop_sound_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_stop_sound(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ EXPECT_NE(STT_STATE_READY, g_current_state);
+
+ ret = stt_unset_stop_sound(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_detailed_result_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_detailed_result(g_stt, __stt_result_time_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_foreach_detailed_result(g_stt, __stt_result_time_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_foreach_detailed_result_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_foreach_detailed_result(NULL, __stt_result_time_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_foreach_detailed_result(NULL, __stt_result_time_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_get_error_message_n)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_error_message(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_get_error_message(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_get_error_message_n1)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_error_message(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ ret = stt_get_error_message(NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_get_error_message_n2)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_error_message(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+ char* err_msg = NULL;
+ ret = stt_get_error_message(g_stt, &err_msg);
+ EXPECT_EQ(ret, STT_ERROR_OPERATION_FAILED);
+}
+
+TEST_F(STTTest, utc_stt_set_private_data_p)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_private_data(g_stt, "gender", "data");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_set_private_data_n)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_private_data(NULL, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_set_private_data_n1)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_private_data(g_stt, "gender", nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_set_private_data_n2)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_private_data(g_stt, NULL, "data");
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_set_private_data_n3)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_private_data(g_stt, "gender", "data");
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_get_private_data_p)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ char *data = NULL;
+ ret = stt_get_private_data(g_stt, "gender", &data);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ free(data);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_get_private_data_n)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_get_private_data(NULL, NULL, nullptr);
+ EXPECT_NE(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_get_private_data_n1)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_get_private_data(g_stt, "gender", nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_get_private_data_n2)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ char* data = NULL;
+ ret = stt_get_private_data(g_stt, NULL, &data);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_get_private_data_n3)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_get_private_data(g_stt, NULL, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ char* data = NULL;
+ ret = stt_get_private_data(g_stt, "gender", &data);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_set_credential_p)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_credential(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_credential(g_stt, "test");
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_set_credential_n)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_credential(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_credential(NULL, nullptr);
+ EXPECT_NE(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_set_credential_n1)
+{
+ int ret = STT_ERROR_NONE;
+ if (false == g_stt_supported) {
+ ret = stt_set_credential(g_stt, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_set_credential(g_stt, nullptr);
+ EXPECT_NE(ret, STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_set_engine_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine_changed_cb(g_stt, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_engine_changed_cb(g_stt, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unset_engine_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_engine_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine_changed_cb(NULL, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_engine_changed_cb(NULL, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_engine_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_engine_changed_cb(NULL, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_set_engine_changed_cb(g_stt, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_engine_changed_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_engine_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_engine_changed_cb(g_stt, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_unset_engine_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_engine_changed_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_engine_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_engine_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_engine_changed_cb_n1)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_engine_changed_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ }
+ else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_engine_changed_cb(g_stt, __stt_engine_changed_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_prepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ while (STT_STATE_READY != g_current_state) {
+ ecore_main_loop_iterate();
+ }
+
+ ret = stt_unset_engine_changed_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ ret = stt_unprepare(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_speech_status_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_speech_status_cb(g_stt, __stt_speech_status_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_speech_status_cb(g_stt, __stt_speech_status_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+
+ ret = stt_unset_speech_status_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_set_speech_status_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_set_speech_status_cb(NULL, __stt_speech_status_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_set_speech_status_cb(NULL, __stt_speech_status_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_speech_status_cb_p)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_speech_status_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ EXPECT_NE(g_stt, nullptr);
+ ret = stt_set_speech_status_cb(g_stt, __stt_speech_status_cb, nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ ret = stt_unset_speech_status_cb(g_stt);
+ EXPECT_EQ(ret, STT_ERROR_NONE);
+ }
+}
+
+TEST_F(STTTest, utc_stt_unset_speech_status_cb_n)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ ret = stt_unset_speech_status_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_NOT_SUPPORTED);
+ } else {
+ ret = stt_unset_speech_status_cb(nullptr);
+ EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER);
+ }
+}
+
+TEST_F(STTTest, utc_stt_create_out_of_memory)
+{
+ int ret = STT_ERROR_NONE;
+
+ stt_mock_calloc_set_up(sizeof(stt_client_s), 0);
+
+ stt_h stt = NULL;
+ ret = stt_create(&stt);
+ EXPECT_EQ(ret, STT_ERROR_OUT_OF_MEMORY);
+
+ stt_mock_calloc_set_up(sizeof(stt_client_s), sizeof(stt_client_s));
+}
+
+} // namespace
projects / platform / core / uifw / stt.git / commitdiff