#include <Ecore.h>
#include <tzplatform_config.h>
#include <vconf.h>
+#include <memory>
#include <stt.h>
#include <stt_internal.h>
mTestUtil->mHandle = nullptr;
}
+TEST_F(STTPreparedTest, utc_stt_destroy_p3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NONE);
+ mTestUtil->mHandle = nullptr;
+}
+
+TEST_F(STTPreparedTest, utc_stt_destroy_p4)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ auto localUtil = std::make_unique<SttTestUtility>();
+
+ mTestUtil->DestroyHandle();
+}
+
TEST_F(STTTest, utc_stt_destroy_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTTest, utc_stt_destroy_n3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_destroy(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ auto destroy_callback = [](stt_h stt, stt_state_e previous, stt_state_e current, void* user_data)
+ {
+ auto util = reinterpret_cast<SttTestUtility *>(user_data);
+ util->mCurrentState = current;
+
+ ASSERT_EQ(util->mHandle, stt);
+ EXPECT_NE(stt_destroy(util->mHandle), STT_ERROR_NONE);
+ };
+
+ EXPECT_EQ(stt_set_state_changed_cb(mHandle, destroy_callback, mTestUtil), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->Prepare(), true);
+}
+
TEST_F(STTTest, utc_stt_prepare_p1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
}
+TEST_F(STTTest, utc_stt_prepare_p2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(mTestUtil->Prepare(), true);
+ EXPECT_EQ(mTestUtil->Unprepare(), true);
+ mTestUtil->WaitUntilEngineTerminated(5);
+
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
+TEST_F(STTTest, utc_stt_prepare_p3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
TEST_F(STTTest, utc_stt_prepare_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_prepare(nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTPreparedTest, utc_stt_prepare_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_prepare_n3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE);
+ mTestUtil->DestroyHandle();
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), false);
+}
+
+// TODO : Check if this scenario is valid
+// TEST_F(STTTest, utc_stt_prepare_n4)
+// {
+// stt_h mHandle = mTestUtil->mHandle;
+// if (false == mTestUtil->IsFeatureSupported()) {
+// EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+// return;
+// }
+
+// char* engine_id = vconf_get_str(VCONFKEY_STT_ENGINE_DEFAULT);
+
+// EXPECT_EQ(vconf_set_str(VCONFKEY_STT_ENGINE_DEFAULT, "test"), 0);
+// EXPECT_EQ(stt_prepare(mHandle), STT_ERROR_NONE);
+// EXPECT_EQ(mTestUtil->IsErrorOccurring(30), true);
+
+// EXPECT_EQ(vconf_set_str(VCONFKEY_STT_ENGINE_DEFAULT, engine_id), 0);
+// }
+
TEST_F(STTPreparedTest, utc_stt_unprepare_p1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_unprepare(nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTTest, utc_stt_unprepare_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->DestroyHandle();
+ EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_unprepare_n3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_unprepare(mHandle), STT_ERROR_INVALID_STATE);
+}
+
TEST_F(STTTest, utc_stt_foreach_supported_engines_p1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_get_engine(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTPreparedTest, utc_stt_get_engine_n2)
+{
+ char *engine_id = nullptr;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_get_engine(mHandle, &engine_id), STT_ERROR_INVALID_STATE);
+}
+
TEST_F(STTTest, utc_stt_set_engine_p1)
{
char *engine_id = nullptr;
EXPECT_EQ(stt_set_silence_detection(mHandle, STT_OPTION_SILENCE_DETECTION_AUTO), STT_ERROR_INVALID_STATE);
}
+TEST_F(STTPreparedTest, utc_stt_start_p1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true);
+}
+
+TEST_F(STTPreparedTest, utc_stt_start_p2)
+{
+ const char *type = STT_RECOGNITION_TYPE_FREE_PARTIAL;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_start(mHandle, nullptr, type), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(stt_start(mHandle, nullptr, type), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_RECORDING, 5), true);
+}
+
TEST_F(STTPreparedTest, utc_stt_start_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_start(mHandle, TEST_LANGUAGE, TEST_RECOG_TYPE), STT_ERROR_INVALID_STATE);
}
+TEST_F(STTPreparedTest, utc_stt_stop_p1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true);
+}
+
TEST_F(STTPreparedTest, utc_stt_stop_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_stop(nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTTest, utc_stt_stop_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_INVALID_STATE);
+
+ ASSERT_EQ(mTestUtil->Prepare(), true);
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_INVALID_STATE);
+
+ mTestUtil->SetTestMode();
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_IN_PROGRESS_TO_PROCESSING);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_PROCESSING, 5), true);
+
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_INVALID_STATE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_IN_PROGRESS_TO_READY);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
+TEST_F(STTPreparedTest, utc_stt_stop_n3)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_stop(mHandle), STT_ERROR_OPERATION_FAILED);
+}
+
+TEST_F(STTPreparedTest, utc_stt_cancel_p1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(mTestUtil->Stop(), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
+TEST_F(STTPreparedTest, utc_stt_cancel_p2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+
+ ASSERT_EQ(mTestUtil->StartAudioStreaming(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(mTestUtil->StopAudioStreaming(), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
TEST_F(STTPreparedTest, utc_stt_cancel_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
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);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_NONE);
+ EXPECT_EQ(stt_cancel(mHandle), STT_ERROR_IN_PROGRESS_TO_READY);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
+TEST_F(STTPreparedTest, utc_stt_get_recording_volume_p1)
+{
+ float vol = 0.0;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_get_recording_volume(mHandle, &vol), STT_ERROR_NONE);
}
TEST_F(STTPreparedTest, utc_stt_get_recording_volume_n1)
EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, nullptr), STT_ERROR_NONE);
}
+TEST_F(STTTest, utc_stt_set_recognition_result_cb_p2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, mTestUtil), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_recognition_result_cb(mHandle, mTestUtil->RecognitionResultCallback, mTestUtil), STT_ERROR_NONE);
+
+ EXPECT_EQ(mTestUtil->Prepare(), true);
+
+ mTestUtil->SetTestMode();
+ ASSERT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+ EXPECT_EQ(mTestUtil->Stop(), true);
+ EXPECT_EQ(mTestUtil->IsResultReceived(5), true);
+ EXPECT_EQ(mTestUtil->IsStateChanged(STT_STATE_READY, 5), true);
+}
+
TEST_F(STTTest, utc_stt_set_recognition_result_cb_n1)
{
if (false == mTestUtil->IsFeatureSupported()) {
}
EXPECT_EQ(stt_set_private_data(nullptr, "gender", "data"), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_set_private_data(mHandle, "server", "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);
}
EXPECT_EQ(stt_set_speech_status_cb(mHandle, nullptr, nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTPreparedTest, utc_stt_set_speech_status_cb_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_speech_status_cb(mHandle, __stt_speech_status_cb, nullptr), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_speech_status_cb(mHandle, __stt_speech_status_cb, nullptr), STT_ERROR_INVALID_STATE);
+}
+
TEST_F(STTTest, utc_stt_unset_speech_status_cb_p1)
{
if (false == mTestUtil->IsFeatureSupported()) {
EXPECT_EQ(stt_unset_speech_status_cb(nullptr), STT_ERROR_INVALID_PARAMETER);
}
+TEST_F(STTPreparedTest, utc_stt_unset_speech_status_cb_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_unset_speech_status_cb(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_unset_speech_status_cb(mHandle), STT_ERROR_INVALID_STATE);
+}
+
TEST_F(STTPreparedTest, utc_stt_get_audio_format_p1)
{
stt_audio_type_e type = STT_AUDIO_TYPE_RAW_S16;
EXPECT_EQ(stt_stop_audio_streaming(mHandle), STT_ERROR_OPERATION_FAILED);
}
+TEST_F(STTPreparedTest, utc_stt_set_server_stt_p1)
+{
+ char *data = (char *)"qa";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", data), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", data), STT_ERROR_NONE);
+}
+
+TEST_F(STTPreparedTest, utc_stt_set_server_stt_n1)
+{
+ char *data = (char *)"qa";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", data), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_server_stt(nullptr, "server", data), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_set_server_stt(mHandle, nullptr, data), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", nullptr), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTTest, utc_stt_set_server_stt_n2)
+{
+ char *data = (char *)"qa";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", data), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_server_stt(mHandle, "server", data), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_change_system_volume_p1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NONE);
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_FARFIELD), STT_ERROR_NONE);
+
+ ASSERT_EQ(mTestUtil->Prepare(), true);
+
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NONE);
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_FARFIELD), STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_change_system_volume_n1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_change_system_volume(nullptr, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_change_system_volume(mHandle, static_cast<stt_system_volume_event_e>(-1)), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTPreparedTest, utc_stt_change_system_volume_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_recover_system_volume_p1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NONE);
+
+ ASSERT_EQ(mTestUtil->Prepare(), true);
+
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_recover_system_volume_p2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ ASSERT_EQ(stt_change_system_volume(mHandle, STT_SYSTEM_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), STT_ERROR_NONE);
+ sleep(1);
+
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_recover_system_volume_n1)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_recover_system_volume(nullptr), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_recover_system_volume(nullptr), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTPreparedTest, utc_stt_recover_system_volume_n2)
+{
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_recover_system_volume(mHandle), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_set_audio_type_p1)
+{
+ const char *audio_id = "test";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NONE);
+
+ EXPECT_EQ(mTestUtil->Prepare(), true);
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NONE);
+}
+
+TEST_F(STTTest, utc_stt_set_audio_type_n1)
+{
+ const char *audio_id = "test";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_set_audio_type(nullptr, audio_id), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_set_audio_type(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTPreparedTest, utc_stt_set_audio_type_n2)
+{
+ const char *audio_id = "test";
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_INVALID_STATE);
+}
+
+TEST_F(STTTest, utc_stt_get_audio_type_p1)
+{
+ const char *audio_id = "test";
+ char *get_id = nullptr;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_get_audio_type(mHandle, &get_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ ASSERT_EQ(stt_set_audio_type(mHandle, audio_id), STT_ERROR_NONE);
+ EXPECT_EQ(stt_get_audio_type(mHandle, &get_id), STT_ERROR_NONE);
+ EXPECT_STREQ(get_id, audio_id);
+
+ EXPECT_EQ(mTestUtil->Prepare(), true);
+ EXPECT_EQ(stt_get_audio_type(mHandle, &get_id), STT_ERROR_NONE);
+ EXPECT_STREQ(get_id, audio_id);
+}
+
+TEST_F(STTTest, utc_stt_get_audio_type_n1)
+{
+ char *get_id = nullptr;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_get_audio_type(mHandle, &get_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ EXPECT_EQ(stt_get_audio_type(nullptr, &get_id), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_get_audio_type(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(STTPreparedTest, utc_stt_get_audio_type_n2)
+{
+ char *get_id = nullptr;
+
+ if (false == mTestUtil->IsFeatureSupported()) {
+ EXPECT_EQ(stt_get_audio_type(mHandle, &get_id), STT_ERROR_NOT_SUPPORTED);
+ return;
+ }
+
+ mTestUtil->SetTestMode();
+ EXPECT_EQ(mTestUtil->Start(TEST_LANGUAGE, TEST_RECOG_TYPE), true);
+
+ EXPECT_EQ(stt_get_audio_type(nullptr, &get_id), STT_ERROR_INVALID_PARAMETER);
+ EXPECT_EQ(stt_get_audio_type(mHandle, nullptr), STT_ERROR_INVALID_PARAMETER);
+}
+
} // namespace