Add new test cases to increse the coverage

- Contents:
This patch adds new test cases for uncovered line. Through this patch,
developers can check the behavior about specific situations.

Change-Id: I5289f5b80609768c7eaa9227eb1ce9e7d9032207
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7a34cd9..e3eebc1 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -14,7 +14,7 @@ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fPIE")
 SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Werror")
 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
 
-SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -std=c++11")
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -std=c++14")
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}")
 
 SET(SOURCES "")

diff --git a/tests/org.tizen.stt-unittests.xml b/tests/org.tizen.stt-unittests.xml
index f7a5832..20df134 100644 (file)
--- a/tests/org.tizen.stt-unittests.xml
+++ b/tests/org.tizen.stt-unittests.xml
@@ -15,5 +15,6 @@
             <privilege>http://tizen.org/privilege/recorder</privilege>
             <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
             <privilege>http://tizen.org/privilege/appmanager.kill</privilege>
+            <privilege>http://tizen.org/privilege/volume.set</privilege>
         </privileges>
 </manifest>

diff --git a/tests/src/stt_unittests.cpp b/tests/src/stt_unittests.cpp
index 7b6bb7c..68c79a2 100644 (file)
--- a/tests/src/stt_unittests.cpp
+++ b/tests/src/stt_unittests.cpp
@@ -18,6 +18,7 @@
 #include <Ecore.h>
 #include <tzplatform_config.h>
 #include <vconf.h>
+#include <memory>
 
 #include <stt.h>
 #include <stt_internal.h>
@@ -170,6 +171,29 @@ TEST_F(STTTest, utc_stt_destroy_p2)
        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()) {
@@ -191,6 +215,26 @@ TEST_F(STTTest, utc_stt_destroy_n2)
        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()) {
@@ -202,6 +246,33 @@ TEST_F(STTTest, utc_stt_prepare_p1)
        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()) {
@@ -212,6 +283,46 @@ TEST_F(STTTest, utc_stt_prepare_n1)
        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()) {
@@ -232,6 +343,27 @@ TEST_F(STTTest, utc_stt_unprepare_n1)
        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()) {
@@ -290,6 +422,18 @@ TEST_F(STTTest, utc_stt_get_engine_n1)
        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;
@@ -508,6 +652,32 @@ TEST_F(STTTest, utc_stt_set_silence_detection_n2)
        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()) {
@@ -538,6 +708,20 @@ TEST_F(STTTest, utc_stt_start_n2)
        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()) {
@@ -551,6 +735,83 @@ TEST_F(STTPreparedTest, utc_stt_stop_n1)
        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()) {
@@ -581,6 +842,27 @@ TEST_F(STTTest, utc_stt_cancel_n2)
        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)
@@ -629,6 +911,24 @@ TEST_F(STTTest, utc_stt_set_recognition_result_cb_p1)
        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()) {
@@ -1094,6 +1394,7 @@ TEST_F(STTPreparedTest, utc_stt_set_private_data_n1)
        }
 
        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);
 }
@@ -1265,6 +1566,16 @@ TEST_F(STTTest, utc_stt_set_speech_status_cb_n1)
        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()) {
@@ -1285,6 +1596,16 @@ TEST_F(STTTest, utc_stt_unset_speech_status_cb_n1)
        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;
@@ -1525,4 +1846,223 @@ TEST_F(STTPreparedTest, utc_stt_stop_audio_streaming_n3)
        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