From 3d56835bc915050987b74ce6599ab2d7fd7de65a Mon Sep 17 00:00:00 2001 From: Suyeon Hwang Date: Wed, 5 Jul 2023 21:17:48 +0900 Subject: [PATCH] Refactor unit tests with utility class - Contents: This patch fixes all unit tests using new utility class from previous commit. Through this change, many duplicated codes in test cases can be removed. Change-Id: Icff147fe2b492f8dfb08b267ad374f9c5a20151f Signed-off-by: Suyeon Hwang --- packaging/stt.spec | 1 + tests/CMakeLists.txt | 1 + tests/org.tizen.stt-unittests.xml | 1 + tests/res/ringtone.wav | Bin 0 -> 149168 bytes tests/src/stt_unittests.cpp | 2938 ++++++++++++------------------------- 5 files changed, 933 insertions(+), 2008 deletions(-) create mode 100755 tests/res/ringtone.wav diff --git a/packaging/stt.spec b/packaging/stt.spec index 06e909d..0d6ed0c 100644 --- a/packaging/stt.spec +++ b/packaging/stt.spec @@ -249,5 +249,6 @@ mkdir -p %{TZ_SYS_RO_SHARE}/voice/test %defattr(-,root,root,-) %{TZ_SYS_RO_PACKAGES}/org.tizen.stt-unittests.xml %{TZ_SYS_RO_APP}/org.tizen.stt-unittests/res/test_pcm.dat +%{TZ_SYS_RO_APP}/org.tizen.stt-unittests/res/ringtone.wav %{TZ_SYS_RO_APP}/org.tizen.stt-unittests/bin/stt-unittests %{_bindir}/tizen-unittests/%{name}/run-unittest.sh diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index ecb866d..7a34cd9 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -45,4 +45,5 @@ SET_TARGET_PROPERTIES(${UNITTEST_STT} PROPERTIES INSTALL(FILES ${CMAKE_SOURCE_DIR}/tests/${PKGNAME}.xml DESTINATION ${TZ_SYS_RO_PACKAGES}) INSTALL(FILES ${CMAKE_SOURCE_DIR}/tests/res/test_pcm.dat DESTINATION ${RESDIR}) +INSTALL(FILES ${CMAKE_SOURCE_DIR}/tests/res/ringtone.wav DESTINATION ${RESDIR}) INSTALL(TARGETS ${UNITTEST_STT} DESTINATION ${BINDIR}) diff --git a/tests/org.tizen.stt-unittests.xml b/tests/org.tizen.stt-unittests.xml index 9281099..f7a5832 100644 --- a/tests/org.tizen.stt-unittests.xml +++ b/tests/org.tizen.stt-unittests.xml @@ -14,5 +14,6 @@ http://tizen.org/privilege/recorder http://tizen.org/privilege/appmanager.launch + http://tizen.org/privilege/appmanager.kill diff --git a/tests/res/ringtone.wav b/tests/res/ringtone.wav new file mode 100755 index 0000000000000000000000000000000000000000..648738920442a745a2c60e5024533047e805ece2 GIT binary patch literal 149168 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 Wfz7~XU^B28*bHn2HUr;d;C}&Nd7w}L literal 0 HcmV?d00001 diff --git a/tests/src/stt_unittests.cpp b/tests/src/stt_unittests.cpp index 3c9283e..7b6bb7c 100644 --- a/tests/src/stt_unittests.cpp +++ b/tests/src/stt_unittests.cpp @@ -17,6 +17,8 @@ #include #include #include +#include + #include #include #include @@ -24,55 +26,29 @@ #include "cynara_mock.h" #include "system_info_mock.h" #include "calloc_mock.h" +#include "test_util.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 const char *TEST_RINGTONE_PATH = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.stt-unittests/res/ringtone.wav"); +static const char *TEST_LANGUAGE = "en_US"; +static const char *TEST_RECOG_TYPE = STT_RECOGNITION_TYPE_FREE_PARTIAL; + +namespace { -static char* g_pcm_data = nullptr; -static long g_pcm_size = 0; static bool __stt_supported_engine_cb(stt_h stt, const char* engine_id, const char* engine_name, void* user_data) { - return true; + 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) -{ + return true; } 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; + return true; } static void __stt_default_language_changed_cb(stt_h stt, const char* previous, const char* current, void *user_data) @@ -87,2520 +63,1466 @@ static void __stt_speech_status_cb(stt_h stt, stt_speech_status_e status, void * { } -static void read_test_pcm() -{ - const char* pcm_path = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.stt-unittests/res/test_pcm.dat"); - FILE* fp_in = fopen(pcm_path, "rb"); - if (fp_in == nullptr) { - return; - } - - fseek(fp_in, 0, SEEK_END); - long size = ftell(fp_in); - fseek(fp_in, 0, SEEK_SET); - if (size <= 0) { - fclose(fp_in); - return; - } - - char* data = (char*)calloc(sizeof(char), size); - if (NULL == data) { - fclose(fp_in); - return; - } - size_t read_size = fread(data, sizeof(char), size, fp_in); - fclose(fp_in); +class STTTest : public testing::Test { +public: + virtual void SetUp() + { + ecore_init(); + mTestUtil = new SttTestUtility(); - if (read_size <= 0) { - free(data); - return; - } + mHandle = mTestUtil->mHandle; + } - g_pcm_size = size; - g_pcm_data = data; -} + virtual void TearDown() + { + /* end of TC */ + mTestUtil->Cancel(); + mTestUtil->UnsetTestMode(); + mTestUtil->Unprepare(); -static bool is_feature_enabled() -{ - bool stt_feature = false; - if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_bool("http://tizen.org/feature/speech.recognition", &stt_feature)) { - return false; - } + delete mTestUtil; + mTestUtil = nullptr; - bool mic_feature = false; - if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_bool("http://tizen.org/feature/microphone", &mic_feature)) { - return false; - } + SttTestUtility::WaitUntilEngineTerminated(1); + ecore_shutdown(); + } - return stt_feature && mic_feature; -} - -class STTTest : public testing::Test { public: - virtual void SetUp() - { - ecore_init(); - - /* start of TC */ - g_stt_supported = is_feature_enabled(); - g_current_state = STT_STATE_CREATED; - g_error = STT_ERROR_NONE; - mIsStreaming = false; - - if (g_stt_supported) { - g_stt = nullptr; - EXPECT_EQ(stt_create(&g_stt), STT_ERROR_NONE); - EXPECT_EQ(stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr), STT_ERROR_NONE); - EXPECT_EQ(stt_set_error_cb(g_stt, __stt_error_cb, nullptr), STT_ERROR_NONE); - } - } - - virtual void TearDown() - { - /* end of TC */ - CancelSttRecording(); - UnprepareStt(); - SetTestMode(false); - - if (true == g_stt_supported) { - EXPECT_EQ(stt_unset_state_changed_cb(g_stt), STT_ERROR_NONE); - EXPECT_EQ(stt_unset_error_cb(g_stt), STT_ERROR_NONE); - EXPECT_EQ(stt_destroy(g_stt), STT_ERROR_NONE); - g_stt = nullptr; - } - - ecore_shutdown(); - } - - bool CancelSttRecording() - { - stt_state_e state = STT_STATE_CREATED; - stt_get_state(g_stt, &state); - if (STT_STATE_READY == state || STT_STATE_CREATED == state) { - return false; - } - - stt_cancel(g_stt); - return IsStateChanged(STT_STATE_READY, 5); - } - - bool UnprepareStt() - { - stt_state_e state = STT_STATE_CREATED; - stt_get_state(g_stt, &state); - if (STT_STATE_READY != state) { - return false; - } - - stt_unprepare(g_stt); - return IsStateChanged(STT_STATE_CREATED, 5); - } - - bool PrepareStt() - { - stt_state_e state = STT_STATE_CREATED; - stt_get_state(g_stt, &state); - if (STT_STATE_CREATED != state) { - return false; - } - - stt_prepare(g_stt); - return IsStateChanged(STT_STATE_READY, 5); - } - - void SetTestMode(bool isTestMode) - { - stt_state_e state = STT_STATE_CREATED; - stt_get_state(g_stt, &state); - if (STT_STATE_READY != state) { - return; - } - - stt_set_private_data(g_stt, "stt_verification", isTestMode ? "true" : "false"); - } - - bool IsStateChanged(stt_state_e state, int wait_delay) - { - mTargetState = state; - auto mainLoopQuitTimer = ecore_timer_add(static_cast(wait_delay), [](void *data) -> Eina_Bool { - ecore_main_loop_quit(); - return EINA_FALSE; - }, nullptr); - - auto stateCheckerTimer = ecore_timer_add(0.0, [](void *data) -> Eina_Bool { - auto instance = reinterpret_cast(data); - if (instance->mTargetState != g_current_state) { - return EINA_TRUE; - } - - ecore_main_loop_quit(); - return EINA_FALSE; - }, this); - - ecore_main_loop_begin(); - - ecore_timer_del(mainLoopQuitTimer); - mainLoopQuitTimer = nullptr; - - ecore_timer_del(stateCheckerTimer); - stateCheckerTimer = nullptr; - - return state == g_current_state; - } - - bool mIsStreaming = false; - stt_state_e mTargetState = STT_STATE_CREATED; + SttTestUtility *mTestUtil = nullptr; + stt_h mHandle = nullptr; }; -TEST_F(STTTest, utc_stt_create_p) -{ - int ret = STT_ERROR_NONE; +class STTPreparedTest : public testing::Test { +public: + virtual void SetUp() + { + ecore_init(); + mTestUtil = new SttTestUtility(); - if (false == g_stt_supported) { - EXPECT_EQ(g_stt, nullptr); - } else { - EXPECT_NE(g_stt, nullptr); + mHandle = mTestUtil->mHandle; + mTestUtil->Prepare(); + } - stt_h stt = NULL; - ret = stt_create(&stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - EXPECT_NE(stt, nullptr); + virtual void TearDown() + { + /* end of TC */ + mTestUtil->Cancel(); + mTestUtil->UnsetTestMode(); + mTestUtil->Unprepare(); - ret = stt_destroy(stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } -} + delete mTestUtil; + mTestUtil = nullptr; -TEST_F(STTTest, utc_stt_create_n) -{ - int ret = STT_ERROR_NONE; + SttTestUtility::WaitUntilEngineTerminated(1); + ecore_shutdown(); + } - 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); +public: + SttTestUtility *mTestUtil = nullptr; + stt_h mHandle = nullptr; +}; - ret = stt_create(&g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } -} -TEST_F(STTTest, utc_stt_destroy_p1) +TEST_F(STTTest, utc_stt_create_p1) { - int ret = STT_ERROR_NONE; + stt_h stt = nullptr; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_create(&stt), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + EXPECT_EQ(stt_create(&stt), STT_ERROR_NONE); + EXPECT_NE(stt, nullptr); - 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); - } + EXPECT_EQ(stt_destroy(stt), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_destroy_p2) +TEST_F(STTTest, utc_stt_create_n1) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_create(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_destroy(stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_create(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_destroy_n) +TEST_F(STTTest, utc_stt_destroy_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + ASSERT_EQ(stt_destroy(mHandle), STT_ERROR_NONE); + mTestUtil->mHandle = nullptr; } -TEST_F(STTTest, utc_stt_destroy_n1) +TEST_F(STTTest, utc_stt_destroy_p2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + ASSERT_EQ(stt_prepare(mHandle), STT_ERROR_NONE); + ASSERT_EQ(stt_destroy(mHandle), STT_ERROR_NONE); + mTestUtil->mHandle = nullptr; } -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) +TEST_F(STTTest, utc_stt_destroy_n1) { - g_temp_current_state = current; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_destroy(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - /* Fail to destroy in callback function */ - g_n2_state_changed_ret = stt_destroy(stt); + ASSERT_EQ(stt_destroy(nullptr), STT_ERROR_INVALID_PARAMETER); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + mTestUtil->DestroyHandle(); + EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_prepare_n) +TEST_F(STTTest, utc_stt_prepare_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); } TEST_F(STTTest, utc_stt_prepare_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_prepare(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_prepare(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unprepare_n) +TEST_F(STTPreparedTest, utc_stt_unprepare_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_NONE); } TEST_F(STTTest, utc_stt_unprepare_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unprepare(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - - EXPECT_EQ(stt_destroy(stt), STT_ERROR_NONE); - } + EXPECT_EQ(stt_unprepare(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_foreach_supported_engines_p) +TEST_F(STTTest, utc_stt_foreach_supported_engines_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_supported_engines(mHandle, __stt_supported_engine_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_supported_engines(mHandle, __stt_supported_engine_cb, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_supported_engines(mHandle, __stt_supported_engine_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_supported_engines(nullptr, __stt_supported_engine_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_foreach_supported_engines(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_engine_p) +TEST_F(STTPreparedTest, utc_stt_foreach_supported_engines_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_supported_engines(mHandle, __stt_supported_engine_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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; - } - } + EXPECT_EQ(stt_foreach_supported_engines(mHandle, __stt_supported_engine_cb, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_get_engine_n) +TEST_F(STTTest, utc_stt_get_engine_p1) { - int ret = STT_ERROR_NONE; + char *engine_id = nullptr; - 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 (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_NOT_SUPPORTED); + return; + } - if (NULL != g_engine_id) { - free(g_engine_id); - g_engine_id = NULL; - } - } + EXPECT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_NONE); + EXPECT_NE(engine_id, nullptr); + free(engine_id); } 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); + char *engine_id = nullptr; - ret = stt_prepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_get_engine(nullptr, &engine_id), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_engine(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_engine_p) +TEST_F(STTTest, utc_stt_set_engine_p1) { - int ret = STT_ERROR_NONE; + char *engine_id = nullptr; - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine(mHandle, engine_id), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_set_engine(g_stt, g_engine_id); - EXPECT_EQ(ret, STT_ERROR_NONE); + ASSERT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_NONE); + EXPECT_EQ(stt_set_engine(mHandle, "test"), STT_ERROR_NONE); - if (NULL != g_engine_id) { - free(g_engine_id); - g_engine_id = NULL; - } - } -} + char *temp_id = nullptr; + ASSERT_EQ(stt_get_engine(mHandle, &temp_id), STT_ERROR_NONE); + EXPECT_STREQ(temp_id, "test"); -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); - } + EXPECT_EQ(stt_set_engine(mHandle, engine_id), STT_ERROR_NONE); + free(temp_id); + free(engine_id); } 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); + const char *engine_id = "test"; - ret = stt_prepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine(mHandle, engine_id), STT_ERROR_NOT_SUPPORTED); + return; + } - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + EXPECT_EQ(stt_set_engine(nullptr, engine_id), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_engine(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); +} - ret = stt_set_engine(g_stt, g_engine_id); - EXPECT_EQ(ret, STT_ERROR_INVALID_STATE); +TEST_F(STTPreparedTest, utc_stt_set_engine_n2) +{ + const char *engine_id = "test"; - if (NULL != g_engine_id) { - free(g_engine_id); - g_engine_id = NULL; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine(mHandle, engine_id), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_set_engine(mHandle, engine_id), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_foreach_supported_languages_p) +TEST_F(STTTest, utc_stt_foreach_supported_languages_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_supported_languages(mHandle, __stt_supported_language_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_supported_languages(mHandle, __stt_supported_language_cb, nullptr), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_foreach_supported_languages_n) +TEST_F(STTTest, utc_stt_foreach_supported_languages_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_supported_languages(mHandle, __stt_supported_language_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_supported_languages(nullptr, __stt_supported_language_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_foreach_supported_languages(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_default_language_p) +TEST_F(STTTest, utc_stt_get_default_language_p1) { - int ret = STT_ERROR_NONE; + char *language = nullptr; - 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 (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_default_language(mHandle, &language), STT_ERROR_NOT_SUPPORTED); + return; + } - if (NULL != g_language) { - free(g_language); - g_language = NULL; - } - } + EXPECT_EQ(stt_get_default_language(mHandle, &language), STT_ERROR_NONE); + EXPECT_NE(language, nullptr); + free(language); } -TEST_F(STTTest, utc_stt_get_default_language_n) +TEST_F(STTTest, utc_stt_get_default_language_n1) { - 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); - } -} + char *language = nullptr; -TEST_F(STTTest, utc_stt_get_state_p) -{ - stt_state_e state; - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_default_language(mHandle, &language), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_get_default_language(nullptr, &language), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_default_language(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_state_n) +TEST_F(STTTest, utc_stt_get_state_p1) { - stt_state_e state; - int ret = STT_ERROR_NONE; + stt_state_e state = STT_STATE_CREATED; - 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); - } -} + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NOT_SUPPORTED); + return; + } -TEST_F(STTTest, utc_stt_is_recognition_type_supported_p) -{ - bool support; - int ret = STT_ERROR_NONE; + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NONE); + EXPECT_EQ(state, STT_STATE_CREATED); + + ASSERT_EQ(mTestUtil->Prepare(), true); + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NONE); + EXPECT_EQ(state, STT_STATE_READY); - 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); + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NONE); + EXPECT_EQ(state, STT_STATE_RECORDING); - 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); + ASSERT_EQ(mTestUtil->Stop(), true); + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NONE); + EXPECT_EQ(state, STT_STATE_PROCESSING); - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); } -TEST_F(STTTest, utc_stt_is_recognition_type_supported_p1) +TEST_F(STTTest, utc_stt_get_state_n1) { - bool support; - int ret = STT_ERROR_NONE; - const char* type = "STT_RECOGNITION_TYPE_TEST"; + stt_state_e state = STT_STATE_CREATED; - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_state(mHandle, &state), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_prepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + EXPECT_EQ(stt_get_state(nullptr, &state), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_state(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); +} - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } +TEST_F(STTPreparedTest, utc_stt_is_recognition_type_supported_p1) +{ + bool support = false; - support = true; - ret = stt_is_recognition_type_supported(g_stt, type, &support); - EXPECT_EQ(ret, STT_ERROR_NONE); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_is_recognition_type_supported_n) +TEST_F(STTPreparedTest, utc_stt_is_recognition_type_supported_p2) { - bool support; - int ret = STT_ERROR_NONE; - const char* type = "STT_RECOGNITION_TYPE_NOT_SUPPORTED"; + const char* type = "STT_RECOGNITION_TYPE_TEST"; + bool support = true; - 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); - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, type, &support), STT_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, type, &support), STT_ERROR_NONE); + EXPECT_EQ(support, false); } -TEST_F(STTTest, utc_stt_is_recognition_type_supported_n1) +TEST_F(STTPreparedTest, utc_stt_is_recognition_type_supported_n1) { - bool support; - int ret = STT_ERROR_NONE; - const char* type = "STT_RECOGNITION_TYPE_NOT_SUPPORTED"; + bool support = true; + + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_is_recognition_type_supported(nullptr, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, nullptr, &support), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, nullptr), STT_ERROR_INVALID_PARAMETER); } 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"; + bool support = false; - 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); - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_NOT_SUPPORTED); + return; + } + + EXPECT_EQ(stt_is_recognition_type_supported(mHandle, STT_RECOGNITION_TYPE_FREE, &support), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_silence_detection_p) +TEST_F(STTPreparedTest, utc_stt_set_silence_detection_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), 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); +TEST_F(STTPreparedTest, utc_stt_set_silence_detection_n1) +{ + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_set_silence_detection(nullptr, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_silence_detection(mHandle, static_cast(-1)), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_silence_detection_n) +TEST_F(STTTest, utc_stt_set_silence_detection_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_silence_detection_n1) +TEST_F(STTPreparedTest, utc_stt_start_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_start(nullptr, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_silence_detection_n2) +TEST_F(STTTest, utc_stt_start_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE); - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + EXPECT_EQ(mTestUtil->Prepare(), true); - 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); + mTestUtil->SetTestMode(); + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE); + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_IN_PROGRESS_TO_RECORDING); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true); - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_start_n) +TEST_F(STTPreparedTest, utc_stt_stop_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + mTestUtil->SetTestMode(); + EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + + EXPECT_EQ(stt_stop(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_start_n1) +TEST_F(STTPreparedTest, utc_stt_cancel_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + EXPECT_EQ(stt_cancel(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_stop_n) +TEST_F(STTTest, utc_stt_cancel_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } -} + EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_INVALID_STATE); -TEST_F(STTTest, utc_stt_cancel_n) -{ - int ret = STT_ERROR_NONE; + EXPECT_EQ(mTestUtil->Prepare(), true); + EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_INVALID_STATE); + + mTestUtil->SetTestMode(); + EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - 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); - } + ASSERT_EQ(stt_stop(mHandle), STT_ERROR_NONE); + EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_IN_PROGRESS_TO_PROCESSING); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true); } -TEST_F(STTTest, utc_stt_cancel_n1) +TEST_F(STTPreparedTest, utc_stt_get_recording_volume_n1) { - int ret = STT_ERROR_NONE; + float vol = 0.0; - 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); - } -} + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_NOT_SUPPORTED); + return; + } -TEST_F(STTTest, utc_stt_get_recording_volume_n) -{ - float vol; - int ret = STT_ERROR_NONE; + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - 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); - } + EXPECT_EQ(stt_get_recording_volume(nullptr, &vol), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_recording_volume(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_recording_volume_n1) +TEST_F(STTTest, utc_stt_get_recording_volume_n2) { - float vol; - int ret = STT_ERROR_NONE; + float vol = 0.0; - 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); - } -} + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_NOT_SUPPORTED); + return; + } -TEST_F(STTTest, utc_stt_set_recognition_result_cb_p) -{ - int ret = STT_ERROR_NONE; + EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_INVALID_STATE); - 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); - } + ASSERT_EQ(mTestUtil->Prepare(), true); + EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_INVALID_STATE); + + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + ASSERT_EQ(mTestUtil->Stop(), true); + EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_recognition_result_cb_n) +TEST_F(STTTest, utc_stt_set_recognition_result_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_recognition_result_cb(nullptr, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_recognition_result_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_recognition_result_cb_n2) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unset_recognition_result_cb(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_recognition_result_cb_n) +TEST_F(STTTest, utc_stt_unset_recognition_result_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_recognition_result_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_recognition_result_cb(mHandle), STT_ERROR_NONE); } TEST_F(STTTest, utc_stt_unset_recognition_result_cb_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_recognition_result_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_recognition_result_cb(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_state_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_unset_recognition_result_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_recognition_result_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_recognition_result_cb(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_state_changed_cb_n) +TEST_F(STTTest, utc_stt_set_state_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_state_changed_cb(mHandle, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_state_changed_cb(mHandle, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_state_changed_cb(mHandle, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_set_state_changed_cb(nullptr, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_state_changed_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_state_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_state_changed_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_state_changed_cb(mHandle, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_state_changed_cb(mHandle, mTestUtil->StateChangedCallback, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_state_changed_cb_n) +TEST_F(STTTest, utc_stt_unset_state_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_state_changed_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_state_changed_cb(mHandle), STT_ERROR_NONE); } 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(); - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_state_changed_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_state_changed_cb(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_error_cb_p) +TEST_F(STTPreparedTest, utc_stt_unset_state_changed_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_state_changed_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_state_changed_cb(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_error_cb_n) +TEST_F(STTTest, utc_stt_set_error_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_error_cb(mHandle, mTestUtil->ErrorCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_error_cb(mHandle, mTestUtil->ErrorCallback, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_error_cb(mHandle, mTestUtil->ErrorCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_error_cb(nullptr, mTestUtil->ErrorCallback, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_error_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_error_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_error_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_error_cb(mHandle, mTestUtil->ErrorCallback, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_error_cb(mHandle, mTestUtil->ErrorCallback, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_error_cb_n) +TEST_F(STTTest, utc_stt_unset_error_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_error_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_error_cb(mHandle), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_error_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_error_cb(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_default_language_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_unset_error_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_error_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_error_cb(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_default_language_changed_cb_n) +TEST_F(STTTest, utc_stt_set_default_language_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, __stt_default_language_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, __stt_default_language_changed_cb, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, __stt_default_language_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_default_language_changed_cb(nullptr, __stt_default_language_changed_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_default_language_changed_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, __stt_default_language_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_default_language_changed_cb(mHandle, __stt_default_language_changed_cb, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_n) +TEST_F(STTTest, utc_stt_unset_default_language_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_default_language_changed_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_default_language_changed_cb(mHandle), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_default_language_changed_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_default_language_changed_cb(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_start_sound_p) +TEST_F(STTPreparedTest, utc_stt_unset_default_language_changed_cb_n2) { - 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; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_default_language_changed_cb(mHandle), 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_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); - } + EXPECT_EQ(stt_unset_default_language_changed_cb(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_start_sound_n) +TEST_F(STTPreparedTest, utc_stt_set_start_sound_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } + + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - 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); - } + EXPECT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_set_start_sound_n1) +TEST_F(STTPreparedTest, utc_stt_set_start_sound_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_start_sound(nullptr, TEST_RINGTONE_PATH), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_start_sound(mHandle, "ringtone.wav"), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_start_sound(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_start_sound_p) +TEST_F(STTTest, utc_stt_set_start_sound_n2) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unset_start_sound(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_start_sound_n) +TEST_F(STTPreparedTest, utc_stt_unset_start_sound_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_start_sound(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - ret = stt_unset_start_sound(nullptr); - EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER); - } + ASSERT_EQ(stt_set_start_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NONE); + EXPECT_EQ(stt_unset_start_sound(mHandle), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_unset_start_sound_n1) +TEST_F(STTPreparedTest, utc_stt_unset_start_sound_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_start_sound(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_start_sound(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_stop_sound_p) +TEST_F(STTTest, utc_stt_unset_start_sound_n2) { - 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(); - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_start_sound(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_start_sound(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_stop_sound_n) +TEST_F(STTPreparedTest, utc_stt_set_stop_sound_p1) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_stop_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - 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); - } + EXPECT_EQ(stt_set_stop_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_set_stop_sound_n1) +TEST_F(STTPreparedTest, utc_stt_set_stop_sound_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_stop_sound(nullptr, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } + + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - 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); - } + EXPECT_EQ(stt_set_stop_sound(nullptr, TEST_RINGTONE_PATH), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_stop_sound(mHandle, "ringtone.wav"), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_stop_sound(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } TEST_F(STTTest, utc_stt_set_stop_sound_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_stop_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NOT_SUPPORTED); + return; + } - 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; - } + if (0 != access(TEST_RINGTONE_PATH, 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); - } + EXPECT_EQ(stt_set_stop_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_stop_sound_p) +TEST_F(STTPreparedTest, utc_stt_unset_stop_sound_p1) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_stop_sound(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + if (0 != access(TEST_RINGTONE_PATH, F_OK)) { + return; + } - 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); - } + ASSERT_EQ(stt_set_stop_sound(mHandle, TEST_RINGTONE_PATH), STT_ERROR_NONE); + EXPECT_EQ(stt_unset_stop_sound(mHandle), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_unset_stop_sound_n) +TEST_F(STTPreparedTest, utc_stt_unset_stop_sound_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_stop_sound(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_stop_sound(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_stop_sound_n1) +TEST_F(STTTest, utc_stt_unset_stop_sound_n2) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_stop_sound(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unset_stop_sound(g_stt); - EXPECT_EQ(ret, STT_ERROR_INVALID_STATE); - } + EXPECT_EQ(stt_unset_stop_sound(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_foreach_detailed_result_p) +TEST_F(STTTest, utc_stt_foreach_detailed_result_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_detailed_result(mHandle, __stt_result_time_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_detailed_result(mHandle, __stt_result_time_cb, nullptr), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_foreach_detailed_result_n) +TEST_F(STTTest, utc_stt_foreach_detailed_result_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_foreach_detailed_result(mHandle, __stt_result_time_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_foreach_detailed_result(nullptr, __stt_result_time_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_foreach_detailed_result(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_error_message_n) +TEST_F(STTPreparedTest, utc_stt_get_error_message_p1) { - 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; - } + char* err_msg = nullptr; - EXPECT_NE(g_stt, nullptr); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_error_message(mHandle, &err_msg), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_get_error_message(g_stt, nullptr); - EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER); + mTestUtil->TerminateCurrentEngine(); + EXPECT_EQ(mTestUtil->IsErrorOccurring(5), true); } 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; - } + char* err_msg = nullptr; - 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; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_error_message(mHandle, &err_msg), 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); + EXPECT_EQ(stt_get_error_message(nullptr, &err_msg), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_error_message(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_private_data_p) +TEST_F(STTTest, utc_stt_get_error_message_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_prepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + char* err_msg = nullptr; - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_error_message(mHandle, &err_msg), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + EXPECT_EQ(stt_get_error_message(mHandle, &err_msg), STT_ERROR_OPERATION_FAILED); } -TEST_F(STTTest, utc_stt_set_private_data_n) +TEST_F(STTPreparedTest, utc_stt_set_private_data_p1) { - 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_private_data(mHandle, "gender", "data"), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_set_private_data(NULL, NULL, nullptr); - EXPECT_EQ(ret, STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_private_data(mHandle, "gender", "data"), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_set_private_data_n1) +TEST_F(STTPreparedTest, 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; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_private_data(mHandle, "gender", "data"), 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); + EXPECT_EQ(stt_set_private_data(nullptr, "gender", "data"), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_private_data(mHandle, nullptr, "data"), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_private_data(mHandle, "gender", nullptr), 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; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_private_data(mHandle, "gender", "data"), 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); + EXPECT_EQ(stt_set_private_data(mHandle, "gender", "data"), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_get_private_data_p) +TEST_F(STTPreparedTest, utc_stt_get_private_data_p1) { - 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 = nullptr; - char *data = NULL; - ret = stt_get_private_data(g_stt, "gender", &data); - EXPECT_EQ(ret, STT_ERROR_NONE); - free(data); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_private_data(mHandle, "gender", &data), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); + EXPECT_EQ(stt_get_private_data(mHandle, "gender", &data), STT_ERROR_NONE); + free(data); } -TEST_F(STTTest, utc_stt_get_private_data_n) +TEST_F(STTPreparedTest, 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; - } + char *data = nullptr; - EXPECT_NE(g_stt, nullptr); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_private_data(mHandle, "gender", &data), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); + EXPECT_EQ(stt_get_private_data(nullptr, "gender", &data), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_private_data(mHandle, nullptr, &data), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_private_data(mHandle, "gender", nullptr), 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; - } + char *data = nullptr; - EXPECT_NE(g_stt, nullptr); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_private_data(mHandle, "gender", &data), STT_ERROR_NOT_SUPPORTED); + return; + } - char* data = NULL; - ret = stt_get_private_data(g_stt, "gender", &data); - EXPECT_EQ(ret, STT_ERROR_INVALID_STATE); + EXPECT_EQ(stt_get_private_data(mHandle, "gender", &data), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_credential_p) +TEST_F(STTTest, utc_stt_set_credential_p1) { - 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; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_credential(mHandle, "test"), STT_ERROR_NOT_SUPPORTED); + return; + } - EXPECT_NE(g_stt, nullptr); + EXPECT_EQ(stt_set_credential(mHandle, "test"), STT_ERROR_NONE); - 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); + EXPECT_EQ(mTestUtil->Prepare(), true); + EXPECT_EQ(stt_set_credential(mHandle, "test"), 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_credential(mHandle, "test"), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_set_credential(g_stt, nullptr); - EXPECT_NE(ret, STT_ERROR_NONE); + EXPECT_EQ(stt_set_credential(nullptr, "test"), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_credential(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_set_engine_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_credential_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_credential(mHandle, "test"), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + mTestUtil->SetTestMode(); + EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + EXPECT_EQ(stt_set_credential(mHandle, "test"), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_engine_changed_cb_n) +TEST_F(STTTest, utc_stt_set_engine_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, __stt_engine_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, __stt_engine_changed_cb, nullptr), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, __stt_engine_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_engine_changed_cb(nullptr, __stt_engine_changed_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_engine_changed_cb_p) +TEST_F(STTPreparedTest, utc_stt_set_engine_changed_cb_n2) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, __stt_engine_changed_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_engine_changed_cb(mHandle, __stt_engine_changed_cb, nullptr), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_unset_engine_changed_cb_n) +TEST_F(STTTest, utc_stt_unset_engine_changed_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_engine_changed_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_engine_changed_cb(mHandle), STT_ERROR_NONE); } 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); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_engine_changed_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - while (STT_STATE_READY != g_current_state) { - ecore_main_loop_iterate(); - } + EXPECT_EQ(stt_unset_engine_changed_cb(nullptr), STT_ERROR_INVALID_PARAMETER); +} - ret = stt_unset_engine_changed_cb(g_stt); - EXPECT_EQ(ret, STT_ERROR_INVALID_STATE); +TEST_F(STTPreparedTest, utc_stt_unset_engine_changed_cb_n2) +{ + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_engine_changed_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - ret = stt_unprepare(g_stt); - EXPECT_EQ(ret, STT_ERROR_NONE); - } + EXPECT_EQ(stt_unset_engine_changed_cb(mHandle), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_set_speech_status_cb_p) +TEST_F(STTTest, utc_stt_set_speech_status_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_speech_status_cb(mHandle, __stt_speech_status_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_speech_status_cb(mHandle, __stt_speech_status_cb, nullptr), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_set_speech_status_cb_n) +TEST_F(STTTest, utc_stt_set_speech_status_cb_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_set_speech_status_cb(mHandle, __stt_speech_status_cb, nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_set_speech_status_cb(nullptr, __stt_speech_status_cb, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_set_speech_status_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_unset_speech_status_cb_p) +TEST_F(STTTest, utc_stt_unset_speech_status_cb_p1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_speech_status_cb(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_speech_status_cb(mHandle), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_unset_speech_status_cb_n) +TEST_F(STTTest, utc_stt_unset_speech_status_cb_n1) { - int ret = STT_ERROR_NONE; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_unset_speech_status_cb(nullptr), STT_ERROR_NOT_SUPPORTED); + return; + } - 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); - } + EXPECT_EQ(stt_unset_speech_status_cb(nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_get_audio_format_p) +TEST_F(STTPreparedTest, utc_stt_get_audio_format_p1) { - ASSERT_NE(g_stt, nullptr); + stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; + int rate = -1; + int num_of_channels = -1; - stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; - int rate = -1; - int num_of_channels = -1; - if (false == g_stt_supported) { - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NONE); + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, &num_of_channels), STT_ERROR_NONE); } TEST_F(STTTest, utc_stt_get_audio_format_n1) { - ASSERT_NE(g_stt, nullptr); + stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; + int rate = -1; + int num_of_channels = -1; - stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; - int rate = -1; - int num_of_channels = -1; - if (false == g_stt_supported) { - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); + return; + } - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_INVALID_STATE); + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, &num_of_channels), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_get_audio_format_n2) +TEST_F(STTPreparedTest, utc_stt_get_audio_format_n2) { - ASSERT_NE(g_stt, nullptr); + stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; + int rate = -1; + int num_of_channels = -1; - stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16; - int rate = -1; - int num_of_channels = -1; - if (false == g_stt_supported) { - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - EXPECT_EQ(stt_get_audio_format(nullptr, &type, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_get_audio_format(g_stt, nullptr, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_get_audio_format(g_stt, &type, nullptr, &num_of_channels), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_get_audio_format(g_stt, &type, &rate, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_audio_format(nullptr, &type, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_audio_format(mHandle, nullptr, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_audio_format(mHandle, &type, nullptr, &num_of_channels), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_get_audio_format(mHandle, &type, &rate, nullptr), STT_ERROR_INVALID_PARAMETER); } -TEST_F(STTTest, utc_stt_start_audio_streaming_p) +TEST_F(STTPreparedTest, utc_stt_start_audio_streaming_p1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED); + return; + } - if (false == g_stt_supported) { - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NOT_SUPPORTED); - return; - } + mTestUtil->SetTestMode(); - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); - - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true); } -TEST_F(STTTest, utc_stt_start_audio_streaming_n1) +TEST_F(STTPreparedTest, utc_stt_start_audio_streaming_n1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; - - if (false == g_stt_supported) { - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NOT_SUPPORTED); - return; - } - - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED); + return; + } - EXPECT_EQ(stt_start_audio_streaming(nullptr, language, type), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_start_audio_streaming(nullptr, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, nullptr), STT_ERROR_INVALID_PARAMETER); } TEST_F(STTTest, utc_stt_start_audio_streaming_n2) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED); + return; + } - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE); - if (false == g_stt_supported) { - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NOT_SUPPORTED); - return; - } + ASSERT_EQ(mTestUtil->Prepare(), true); + mTestUtil->SetTestMode(); - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_INVALID_STATE); + ASSERT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE); + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_IN_PROGRESS_TO_RECORDING); + ASSERT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true); - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE); - ASSERT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - ASSERT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); - - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_INVALID_STATE); + ASSERT_EQ(mTestUtil->StopAudioStreaming(), true); + EXPECT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE); } -TEST_F(STTTest, utc_stt_send_audio_streaming_p) +TEST_F(STTPreparedTest, utc_stt_send_audio_streaming_p1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - read_test_pcm(); - ASSERT_NE(g_pcm_data, nullptr); - ASSERT_GT(g_pcm_size, 0); - - if (false == g_stt_supported) { - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_NOT_SUPPORTED); + return; + } - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; + mTestUtil->SetTestMode(); + mTestUtil->GetTestPCMData(); - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - ASSERT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - ASSERT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); - - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NONE); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_NONE); } -TEST_F(STTTest, utc_stt_send_audio_streaming_n1) +TEST_F(STTPreparedTest, utc_stt_send_audio_streaming_n1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - read_test_pcm(); - ASSERT_NE(g_pcm_data, nullptr); - ASSERT_GT(g_pcm_size, 0); - - if (false == g_stt_supported) { - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED); - return; - } - - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + mTestUtil->SetTestMode(); + mTestUtil->GetTestPCMData(); - ASSERT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - ASSERT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - EXPECT_EQ(stt_send_audio_streaming(nullptr, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_send_audio_streaming(g_stt, nullptr, g_pcm_size), STT_ERROR_INVALID_PARAMETER); - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, 0), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_send_audio_streaming(nullptr, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_send_audio_streaming(mHandle, nullptr, mTestUtil->mPCMSize), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, 0), STT_ERROR_INVALID_PARAMETER); } TEST_F(STTTest, utc_stt_send_audio_streaming_n2) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_NOT_SUPPORTED); + return; + } - read_test_pcm(); - ASSERT_NE(g_pcm_data, nullptr); - ASSERT_GT(g_pcm_size, 0); + mTestUtil->GetTestPCMData(); - if (false == g_stt_supported) { - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED); - return; - } + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_INVALID_STATE); - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE); + ASSERT_EQ(mTestUtil->Prepare(), true); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_INVALID_STATE); - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE); -} - -TEST_F(STTTest, utc_stt_send_audio_streaming_n3) -{ - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; + mTestUtil->SetTestMode(); + ASSERT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_INVALID_STATE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true); - read_test_pcm(); - ASSERT_NE(g_pcm_data, nullptr); - ASSERT_GT(g_pcm_size, 0); + ASSERT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NONE); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_IN_PROGRESS_TO_PROCESSING); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_INVALID_STATE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 10), true); - if (false == g_stt_supported) { - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED); - return; - } + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + ASSERT_EQ(stt_cancel(mHandle), STT_ERROR_NONE); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_IN_PROGRESS_TO_READY); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); +} - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; +TEST_F(STTPreparedTest, utc_stt_send_audio_streaming_n3) +{ + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + mTestUtil->GetTestPCMData(); - ASSERT_EQ(stt_start(g_stt, language, type), STT_ERROR_NONE); - ASSERT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_OPERATION_FAILED); + EXPECT_EQ(stt_send_audio_streaming(mHandle, mTestUtil->mPCMData, mTestUtil->mPCMSize), STT_ERROR_OPERATION_FAILED); } -TEST_F(STTTest, utc_stt_stop_audio_streaming_p) +TEST_F(STTPreparedTest, utc_stt_stop_audio_streaming_p1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - if (false == g_stt_supported) { - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); - - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_PROCESSING, 5), true); - EXPECT_EQ(IsStateChanged(STT_STATE_READY, 5), true); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NONE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); } -TEST_F(STTTest, utc_stt_stop_audio_streaming_n1) +TEST_F(STTPreparedTest, utc_stt_stop_audio_streaming_n1) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - if (false == g_stt_supported) { - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED); - return; - } + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); - - EXPECT_EQ(stt_stop_audio_streaming(nullptr), STT_ERROR_INVALID_PARAMETER); + EXPECT_EQ(stt_stop_audio_streaming(nullptr), STT_ERROR_INVALID_PARAMETER); } TEST_F(STTTest, utc_stt_stop_audio_streaming_n2) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - if (false == g_stt_supported) { - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED); - return; - } + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_INVALID_STATE); - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE); + ASSERT_EQ(mTestUtil->Prepare(), true); + mTestUtil->SetTestMode(); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_INVALID_STATE); - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE); + ASSERT_EQ(stt_start_audio_streaming(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_INVALID_STATE); + ASSERT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true); - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; - EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NONE); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_IN_PROGRESS_TO_PROCESSING); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true); - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_PROCESSING, 5), true); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_INVALID_STATE); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE); + ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true); + ASSERT_EQ(stt_cancel(mHandle), STT_ERROR_NONE); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_IN_PROGRESS_TO_READY); + EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true); } -TEST_F(STTTest, utc_stt_stop_audio_streaming_n3) +TEST_F(STTPreparedTest, utc_stt_stop_audio_streaming_n3) { - ASSERT_NE(g_stt, nullptr); - mIsStreaming = true; - - if (false == g_stt_supported) { - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED); - return; - } - - ASSERT_EQ(PrepareStt(), true); - SetTestMode(true); + if (false == mTestUtil->IsFeatureSupported()) { + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_NOT_SUPPORTED); + return; + } - const char *language = "en_US"; - const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL; - EXPECT_EQ(stt_start(g_stt, language, type), STT_ERROR_NONE); - EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true); + mTestUtil->SetTestMode(); + ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true); - EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_OPERATION_FAILED); + EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_OPERATION_FAILED); } } // namespace -- 2.7.4