#include <gtest/gtest.h>
#include <Ecore.h>
#include <tzplatform_config.h>
+#include <vconf.h>
+
#include <stt.h>
#include <stt_internal.h>
#include <system_info.h>
#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)
{
}
-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<double>(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<STTTest *>(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<stt_option_silence_detection_e>(-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
projects / platform / core / uifw / stt.git / commitdiff