From: Suyeon Hwang Date: Wed, 5 Jul 2023 12:17:48 +0000 (+0900) Subject: Refactor unit tests with utility class X-Git-Tag: accepted/tizen/unified/20230726.020702~6 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F85%2F295385%2F3;p=platform%2Fcore%2Fuifw%2Fstt.git 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 --- 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 0000000..6487389 Binary files /dev/null and b/tests/res/ringtone.wav differ 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