#include <gtest/gtest.h>
#include <Ecore.h>
+#include <tzplatform_config.h>
#include <stt.h>
+#include <stt_internal.h>
#include <system_info.h>
-#include "../../client/stt_client.h"
#include "cynara_mock.h"
#include "system_info_mock.h"
static bool g_stt_supported = false;
static stt_error_e g_error = STT_ERROR_NONE;
+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;
{
}
+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);
+
+ if (read_size <= 0) {
+ free(data);
+ return;
+ }
+
+ g_pcm_size = size;
+ g_pcm_data = data;
+}
+
static bool is_feature_enabled()
{
bool stt_feature = false;
}
class STTTest : public testing::Test {
- public:
- virtual void SetUp() {
- ecore_init();
-
- cynara_check_set_result(CYNARA_API_ACCESS_ALLOWED);
-
- /* start of TC */
- int ret = -1;
- g_stt_supported = is_feature_enabled();
- g_current_state = STT_STATE_CREATED;
- g_error = STT_ERROR_NONE;
-
- if (g_stt_supported) {
- g_stt = NULL;
- ret = stt_create(&g_stt);
- EXPECT_EQ(ret, STT_ERROR_NONE);
-
- ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, nullptr);
- EXPECT_EQ(ret, STT_ERROR_NONE);
- ret = stt_set_error_cb(g_stt, __stt_error_cb, nullptr);
- EXPECT_EQ(ret, STT_ERROR_NONE);
- }
+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 */
- int ret = -1;
- if (true == g_stt_supported) {
- ret = stt_unset_state_changed_cb(g_stt);
- EXPECT_EQ(ret, STT_ERROR_NONE);
- ret = stt_unset_error_cb(g_stt);
- EXPECT_EQ(ret, STT_ERROR_NONE);
- ret = stt_destroy(g_stt);
- EXPECT_EQ(ret, STT_ERROR_NONE);
- }
- g_stt = NULL;
- ecore_shutdown();
+ 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;
};
TEST_F(STTTest, utc_stt_create_p)
ret = stt_unprepare(stt);
EXPECT_EQ(ret, STT_ERROR_INVALID_STATE);
+
+ EXPECT_EQ(stt_destroy(stt), STT_ERROR_NONE);
}
}
}
}
+TEST_F(STTTest, utc_stt_get_audio_format_p)
+{
+ ASSERT_NE(g_stt, nullptr);
+
+ 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;
+ }
+
+ ASSERT_EQ(PrepareStt(), true);
+ EXPECT_EQ(stt_get_audio_format(g_stt, &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;
+ if (false == g_stt_supported) {
+ EXPECT_EQ(stt_get_audio_format(g_stt, &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);
+}
+
+TEST_F(STTTest, 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;
+ if (false == g_stt_supported) {
+ EXPECT_EQ(stt_get_audio_format(g_stt, &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);
+}
+
+TEST_F(STTTest, utc_stt_start_audio_streaming_p)
+{
+ 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);
+
+ EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE);
+ EXPECT_EQ(IsStateChanged(STT_STATE_RECORDING, 5), true);
+}
+
+TEST_F(STTTest, 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);
+
+ 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);
+}
+
+TEST_F(STTTest, utc_stt_start_audio_streaming_n2)
+{
+ 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;
+ }
+
+ EXPECT_EQ(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_INVALID_STATE);
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(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_start_audio_streaming(g_stt, language, type), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_send_audio_streaming_p)
+{
+ 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;
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(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);
+}
+
+TEST_F(STTTest, 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;
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(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(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);
+}
+
+TEST_F(STTTest, utc_stt_send_audio_streaming_n2)
+{
+ 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;
+ }
+
+ EXPECT_EQ(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), 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;
+
+ 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;
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(true);
+
+ ASSERT_EQ(stt_start(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_OPERATION_FAILED);
+}
+
+TEST_F(STTTest, utc_stt_stop_audio_streaming_p)
+{
+ 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);
+
+ 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);
+}
+
+TEST_F(STTTest, 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;
+ }
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(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);
+}
+
+TEST_F(STTTest, utc_stt_stop_audio_streaming_n2)
+{
+ 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;
+ }
+
+ EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+
+ ASSERT_EQ(PrepareStt(), true);
+ SetTestMode(true);
+ EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+
+ 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(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, 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);
+
+ 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);
+
+ EXPECT_EQ(stt_stop_audio_streaming(g_stt), STT_ERROR_OPERATION_FAILED);
+}
+
} // namespace
projects / platform / core / uifw / stt.git / commitdiff