#include <stt.h>
#include <stdlib.h>
#include <system_info.h>
+#include <package_manager.h>
#include <fcntl.h>
#include <unistd.h>
#include <dlog.h>
} \
} while (0)
+static const char *TEST_LANGUAGE = "en_US";
+static const char *TEST_RECOG_TYPE = STT_RECOGNITION_TYPE_FREE_PARTIAL;
+
stt_h g_stt = NULL;
static char *g_engine_id = NULL;
static char *g_language = NULL;
static bool g_stt_supported = false;
static stt_error_e g_error;
+static char g_test_ringtone_path[256];
+static char g_test_pcm_path[256];
+static char* g_pcm_data = NULL;
+static size_t g_pcm_size = 0;
+
static void __stt_state_changed_cb(stt_h stt, stt_state_e previous, stt_state_e current, void* user_data);
static void __stt_error_cb(stt_h stt, stt_error_e reason, void *user_data);
+static void set_test_mode(void)
+{
+ stt_state_e state = STT_STATE_CREATED;
+ stt_get_state(g_stt, &state);
+ if (STT_STATE_READY != state) {
+ return false;
+ }
+
+ stt_set_private_data(g_stt, "stt_verification", "true");
+}
+
+static void unset_test_mode(void)
+{
+ stt_state_e state = STT_STATE_CREATED;
+ stt_get_state(g_stt, &state);
+ if (STT_STATE_READY != state) {
+ return false;
+ }
+
+ stt_set_private_data(g_stt, "stt_verification", "false");
+}
+
+static Eina_Bool quit_main_loop_for_checking(void *data)
+{
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+static Eina_Bool check_current_state(void *data)
+{
+ const stt_state_e target_state = *((stt_state_e *)data);
+ if (g_current_state != target_state) {
+ return EINA_TRUE;
+ }
+
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+static bool is_state_changed(stt_state_e state, int duration)
+{
+ Ecore_Timer *main_loop_quit_timer = ecore_timer_add((double)duration, quit_main_loop_for_checking, NULL);
+ Ecore_Timer *checker_timer = ecore_timer_add(0.0, check_current_state, &state);
+
+ if (NULL == main_loop_quit_timer || NULL == checker_timer) {
+ return false;
+ }
+
+ ecore_main_loop_begin();
+
+ ecore_timer_del(main_loop_quit_timer);
+ ecore_timer_del(checker_timer);
+
+ return (g_current_state == state);
+}
+
+static void create_handle(void)
+{
+ g_current_state = STT_STATE_CREATED;
+ g_error = TIZEN_ERROR_NONE;
+ g_stt = NULL;
+
+ package_info_h info = NULL;
+ package_info_create("org.tizen.stt-native-utc", &info);
+
+ char *root_path = NULL;
+ package_info_get_root_path(info, &root_path);
+
+ if (NULL != root_path) {
+ snprintf(g_test_ringtone_path, 256, "%s/res/ringtone.wav", root_path);
+ snprintf(g_test_pcm_path, 256, "%s/res/test_pcm.dat", root_path);
+ free(root_path);
+ }
+
+ package_info_destroy(info);
+
+ assert_eq(stt_create(&g_stt), STT_ERROR_NONE);
+
+ assert_eq(stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, NULL), STT_ERROR_NONE);
+ assert_eq(stt_set_error_cb(g_stt, __stt_error_cb, NULL), STT_ERROR_NONE);
+}
+
+static bool prepare_handle(void)
+{
+ 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 is_state_changed(STT_STATE_READY, 5);
+}
+
+static bool unprepare_handle(void)
+{
+ stt_state_e state = STT_STATE_CREATED;
+ stt_get_state(g_stt, &state);
+ if (STT_STATE_READY != state) {
+ return false;
+ }
+
+ stt_prepare(g_stt);
+ return is_state_changed(STT_STATE_CREATED, 5);
+}
+
+static bool start_recording(const char* language, const char* type)
+{
+ assert_eq(stt_start(g_stt, language, type), STT_ERROR_NONE);
+ return is_state_changed(STT_STATE_RECORDING, 5);
+}
+
+static bool stop_recording(void)
+{
+ assert_eq(stt_stop(g_stt), STT_ERROR_NONE);
+ return is_state_changed(STT_STATE_PROCESSING, 5);
+}
+
+static bool start_audio_streaming(const char* language, const char* type)
+{
+ assert_eq(stt_start_audio_streaming(g_stt, language, type), STT_ERROR_NONE);
+ return is_state_changed(STT_STATE_RECORDING, 5);
+}
+
+static bool stop_audio_streaming(void)
+{
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE);
+ return is_state_changed(STT_STATE_PROCESSING, 5);
+}
+
+static void cancel_recognition(void)
+{
+ stt_state_e state = STT_STATE_CREATED;
+ stt_get_state(g_stt, &state);
+ if (STT_STATE_CREATED == state || STT_STATE_READY == state) {
+ return;
+ }
+
+ stt_cancel(g_stt);
+ is_state_changed(STT_STATE_READY, 5);
+}
+
+static void get_test_pcm_data()
+{
+ FILE* fp_in = fopen(g_test_pcm_path, "rb");
+ if (fp_in == NULL) {
+ 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;
+}
+
+
void utc_stt_startup(void)
{
/* start of TC */
- int ret = -1;
g_stt_supported = TCTCheckSystemInfoFeatureSupported(MICROPHONE_FEATURE, API_NAMESPACE) &&
TCTCheckSystemInfoFeatureSupported(SPEECH_RECOGNITION_FEATURE, API_NAMESPACE);
- g_current_state = 0;
- g_error = TIZEN_ERROR_NONE;
-
if (g_stt_supported) {
- g_stt = NULL;
- ret = stt_create(&g_stt);
- assert_eq(ret, STT_ERROR_NONE);
- ret = stt_set_state_changed_cb(g_stt, __stt_state_changed_cb, NULL);
- assert_eq(ret, STT_ERROR_NONE);
- ret = stt_set_error_cb(g_stt, __stt_error_cb, NULL);
- assert_eq(ret, STT_ERROR_NONE);
+ create_handle();
}
}
void utc_stt_cleanup(void)
{
/* end of TC */
- int ret = -1;
if (true == g_stt_supported) {
- ret = stt_unset_state_changed_cb(g_stt);
- assert_eq(ret, STT_ERROR_NONE);
- ret = stt_unset_error_cb(g_stt);
- assert_eq(ret, STT_ERROR_NONE);
- ret = stt_destroy(g_stt);
- assert_eq(ret, STT_ERROR_NONE);
+ cancel_recognition();
+ unset_test_mode();
+ unprepare_handle();
+
+ assert_eq(stt_unset_state_changed_cb(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_unset_error_cb(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_destroy(g_stt), STT_ERROR_NONE);
+ g_stt = NULL;
}
- g_stt = NULL;
+ free(g_pcm_data);
+ g_pcm_data = NULL;
+ g_pcm_size = 0;
+
+ g_stt = NULL;
}
static bool __stt_supported_engine_cb(stt_h stt, const char* engine_id, const char* engine_name, void* user_data)
return 0;
}
+/**
+ * @testcase utc_stt_stop_n2
+ * @since_tizen 2.3
+ * @description Negative UTC for stop recording for processing (Operation failed in recording state by stt_start_audio_streaming())
+ */
+int utc_stt_stop_n2(void)
+{
+ int ret = STT_ERROR_NONE;
+
+ if (false == g_stt_supported) {
+ assert_eq(stt_stop(g_stt), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE);
+ assert_eq(stt_stop(g_stt), STT_ERROR_OPERATION_FAILED);
+
+ return 0;
+}
+
/**
* @testcase utc_stt_cancel_p
* @since_tizen 2.3
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");
+ ret = stt_set_start_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
} else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
ecore_main_loop_iterate();
}
- ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_start_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_NONE);
ret = stt_unprepare(g_stt);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
}
else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
/* check invalid state */
assert_neq(g_stt, NULL);
- ret = stt_set_start_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_start_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_INVALID_STATE);
}
ret = stt_unset_start_sound(g_stt);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
} else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
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");
+ ret = stt_set_start_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_NONE);
ret = stt_unset_start_sound(g_stt);
ret = stt_set_stop_sound(g_stt, "test.wav");
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
} else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
ecore_main_loop_iterate();
}
- ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_stop_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_NONE);
ret = stt_unprepare(g_stt);
ret = stt_set_stop_sound(g_stt, NULL);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
} else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
ecore_main_loop_iterate();
}
- ret = stt_set_stop_sound(NULL, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_stop_sound(NULL, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_INVALID_PARAMETER);
ret = stt_unprepare(g_stt);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
}
else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
assert_neq(g_stt, NULL);
- ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_stop_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_INVALID_STATE);
}
ret = stt_unset_stop_sound(g_stt);
assert_eq(ret, STT_ERROR_NOT_SUPPORTED);
} else {
- if (0 != access("/opt/usr/apps/core-stt-tests/data/ringtone.wav", F_OK)) {
+ if (0 != access(g_test_ringtone_path, F_OK)) {
return 0;
}
ecore_main_loop_iterate();
}
- ret = stt_set_stop_sound(g_stt, "/opt/usr/apps/core-stt-tests/data/ringtone.wav");
+ ret = stt_set_stop_sound(g_stt, g_test_ringtone_path);
assert_eq(ret, STT_ERROR_NONE);
ret = stt_unset_stop_sound(g_stt);
}
return 0;
-}
\ No newline at end of file
+}
+
+/**
+ * @testcase utc_stt_get_audio_format_p1
+ * @since_tizen 8.0
+ * @description Positive UTC to get recognizable audio format information
+ */
+int utc_stt_get_audio_format_p1(void)
+{
+ stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16;
+ int rate = -1;
+ int num_of_channels = -1;
+
+ if (false == g_stt_supported) {
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NONE);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_get_audio_format_n1
+ * @since_tizen 8.0
+ * @description Negative UTC to get recognizable audio format information (Invalid state)
+ */
+int utc_stt_get_audio_format_n1(void)
+{
+ stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16;
+ int rate = -1;
+ int num_of_channels = -1;
+
+ if (false == g_stt_supported) {
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_INVALID_STATE);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_get_audio_format_n2
+ * @since_tizen 8.0
+ * @description Negative UTC to get recognizable audio format information (Invalid parameter)
+ */
+int utc_stt_get_audio_format_n2(void)
+{
+ stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16;
+ int rate = -1;
+ int num_of_channels = -1;
+
+ if (false == g_stt_supported) {
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, &num_of_channels), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ assert_eq(stt_get_audio_format(NULL, &type, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_get_audio_format(g_stt, NULL, &rate, &num_of_channels), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_get_audio_format(g_stt, &type, NULL, &num_of_channels), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_get_audio_format(g_stt, &type, &rate, NULL), STT_ERROR_INVALID_PARAMETER);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_start_audio_streaming_p1
+ * @since_tizen 8.0
+ * @description Postive UTC to start audio streaming
+ */
+int utc_stt_start_audio_streaming_p1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE);
+ assert_eq(is_state_changed(STT_STATE_RECORDING, 5), true);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_start_audio_streaming_n1
+ * @since_tizen 8.0
+ * @description Negative UTC to start audio streaming (Invalid parameter)
+ */
+int utc_stt_start_audio_streaming_n1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ assert_eq(stt_start_audio_streaming(NULL, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, NULL), STT_ERROR_INVALID_PARAMETER);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_start_audio_streaming_n2
+ * @since_tizen 8.0
+ * @description Negative UTC to start audio streaming (Invalid state)
+ */
+int utc_stt_start_audio_streaming_n2(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE);
+
+ assert_eq(prepare_handle(), true);
+ set_test_mode();
+
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE);
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_IN_PROGRESS_TO_RECORDING);
+ assert_eq(is_state_changed(STT_STATE_RECORDING, 5), true);
+
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE);
+
+ assert_eq(stop_audio_streaming(), true);
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_send_audio_streaming_p1
+ * @since_tizen 8.0
+ * @description Positive UTC to send audio streaming data to service engine
+ */
+int utc_stt_send_audio_streaming_p1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+ get_test_pcm_data();
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NONE);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_send_audio_streaming_n1
+ * @since_tizen 8.0
+ * @description Negative UTC to send audio streaming data to service engine (Invalid parameter)
+ */
+int utc_stt_send_audio_streaming_n1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+ get_test_pcm_data();
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_send_audio_streaming(NULL, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_send_audio_streaming(g_stt, NULL, g_pcm_size), STT_ERROR_INVALID_PARAMETER);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, 0), STT_ERROR_INVALID_PARAMETER);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_send_audio_streaming_n2
+ * @since_tizen 8.0
+ * @description Negative UTC to send audio streaming data to service engine (Invalid state)
+ */
+int utc_stt_send_audio_streaming_n2(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ get_test_pcm_data();
+
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE);
+
+ assert_eq(prepare_handle(), true);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE);
+
+ set_test_mode();
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE);
+ assert_eq(is_state_changed(STT_STATE_RECORDING, 5), true);
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_IN_PROGRESS_TO_PROCESSING);
+ assert_eq(is_state_changed(STT_STATE_PROCESSING, 5), true);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_INVALID_STATE);
+ assert_eq(is_state_changed(STT_STATE_READY, 10), true);
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ assert_eq(stt_cancel(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_IN_PROGRESS_TO_READY);
+ assert_eq(is_state_changed(STT_STATE_READY, 5), true);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_send_audio_streaming_n3
+ * @since_tizen 8.0
+ * @description Negative UTC to send audio streaming data to service engine (Operation failed in recording state by stt_start())
+ */
+int utc_stt_send_audio_streaming_n3(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+ get_test_pcm_data();
+
+ assert_eq(start_recording(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_send_audio_streaming(g_stt, g_pcm_data, g_pcm_size), STT_ERROR_OPERATION_FAILED);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_stop_audio_streaming_p1
+ * @since_tizen 8.0
+ * @description Postive UTC to stop audio streaming
+ */
+int utc_stt_stop_audio_streaming_p1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE);
+ assert_eq(is_state_changed(STT_STATE_PROCESSING, 5), true);
+ assert_eq(is_state_changed(STT_STATE_READY, 5), true);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_stop_audio_streaming_n1
+ * @since_tizen 8.0
+ * @description Negative UTC to stop audio streaming (Invalid parameter)
+ */
+int utc_stt_stop_audio_streaming_n1(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_stop_audio_streaming(NULL), STT_ERROR_INVALID_PARAMETER);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_stop_audio_streaming_n2
+ * @since_tizen 8.0
+ * @description Negative UTC to stop audio streaming (Invalid state)
+ */
+int utc_stt_stop_audio_streaming_n2(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+
+ assert_eq(prepare_handle(), true);
+ set_test_mode();
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+
+ assert_eq(stt_start_audio_streaming(g_stt, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE);
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+ assert_eq(is_state_changed(STT_STATE_RECORDING, 5), true);
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_IN_PROGRESS_TO_PROCESSING);
+ assert_eq(is_state_changed(STT_STATE_PROCESSING, 5), true);
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_INVALID_STATE);
+ assert_eq(is_state_changed(STT_STATE_READY, 5), true);
+
+ assert_eq(start_audio_streaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ assert_eq(stt_cancel(g_stt), STT_ERROR_NONE);
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_IN_PROGRESS_TO_READY);
+ assert_eq(is_state_changed(STT_STATE_READY, 5), true);
+
+ return 0;
+}
+
+/**
+ * @testcase utc_stt_stop_audio_streaming_n3
+ * @since_tizen 8.0
+ * @description Negative UTC to stop audio streaming (Operation failed in recording state by stt_start())
+ */
+int utc_stt_stop_audio_streaming_n3(void)
+{
+ if (false == g_stt_supported) {
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_NOT_SUPPORTED);
+ return 0;
+ }
+
+ prepare_handle();
+
+ set_test_mode();
+
+ assert_eq(start_recording(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ assert_eq(stt_stop_audio_streaming(g_stt), STT_ERROR_OPERATION_FAILED);
+
+ return 0;
+}
projects / test / tct / native / api.git / commitdiff