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: I192b38e190f4b59991c06d2865df0b37b4a8914b

diff --git a/tests/src/vc_command_unittests.cpp b/tests/src/vc_command_unittests.cpp
index fc69406..93ec705 100644 (file)
--- a/tests/src/vc_command_unittests.cpp
+++ b/tests/src/vc_command_unittests.cpp
@@ -118,6 +118,10 @@ TEST_F(VCCommandTest, utc_vc_cmd_list_destroy_n1)
        }
 
        EXPECT_EQ(vc_cmd_list_destroy(nullptr, false), VC_ERROR_INVALID_PARAMETER);
+
+       vc_cmd_list_h list = VcCommonTestUtility::CreateTestCommandList();
+       EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE);
+       EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_INVALID_PARAMETER);
 }
 
 /**
@@ -246,6 +250,37 @@ TEST_F(VCCommandTest, utc_vc_cmd_list_remove_p1)
 }
 
 /**
+ * @testcase           utc_vc_cmd_list_remove_p2
+ * @since_tizen                2.4
+ * @description                Positive UTC to remove command in command list
+ */
+TEST_F(VCCommandTest, utc_vc_cmd_list_remove_p2)
+{
+       vc_cmd_list_h list = nullptr;
+       vc_cmd_h command = nullptr;
+
+       if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
+               EXPECT_EQ(vc_cmd_list_remove(list, command), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       list = VcCommonTestUtility::CreateTestCommandList();
+       command = VcCommonTestUtility::CreateTestCommand("test");
+
+       ASSERT_EQ(vc_cmd_list_add(list, command), VC_ERROR_NONE);
+       EXPECT_EQ(vc_cmd_list_last(list), VC_ERROR_NONE);
+       EXPECT_EQ(vc_cmd_list_remove(list, command), VC_ERROR_NONE);
+
+       EXPECT_EQ(vc_cmd_list_remove_all(list, true), VC_ERROR_NONE);
+
+       ASSERT_EQ(vc_cmd_list_add(list, command), VC_ERROR_NONE);
+       EXPECT_EQ(vc_cmd_list_remove(list, command), VC_ERROR_NONE);
+
+       EXPECT_EQ(vc_cmd_list_destroy(list, true), VC_ERROR_NONE);
+       EXPECT_EQ(vc_cmd_destroy(command), VC_ERROR_NONE);
+}
+
+/**
  * @testcase           utc_vc_cmd_list_remove_n1
  * @since_tizen                2.4
  * @description                Negative UTC to remove command in command list (Invalid parameter)

diff --git a/tests/src/vc_mgr_test_util.cpp b/tests/src/vc_mgr_test_util.cpp
index 699526f..db17219 100644 (file)
--- a/tests/src/vc_mgr_test_util.cpp
+++ b/tests/src/vc_mgr_test_util.cpp
@@ -34,6 +34,7 @@ VcMgrTestUtility::VcMgrTestUtility()
        mSetSelectedResultReturn = VC_ERROR_OPERATION_FAILED;
        mResultReceived = false;
        mSpeechDetected = false;
+       mLanguageChanged = false;
 
        mErrorMessage = nullptr;
 
@@ -83,7 +84,7 @@ bool VcMgrTestUtility::AllResultCallback(vc_result_event_e event, vc_cmd_list_h
        auto instance = reinterpret_cast<VcMgrTestUtility *>(user_data);
 
        instance->mAllResultReceived = true;
-       instance->mSetSelectedResultReturn = vc_mgr_set_selected_results(instance->mDefaultCommandList);
+       instance->mSetSelectedResultReturn = vc_mgr_set_selected_results(vc_cmd_list);
        return false;
 }
 
@@ -99,6 +100,12 @@ void VcMgrTestUtility::SpeechDetectedCallback(void *user_data)
        instance->mSpeechDetected = true;
 }
 
+void VcMgrTestUtility::LanguageChangedCallback(const char* previous, const char* current, void* user_data)
+{
+       auto instance = reinterpret_cast<VcMgrTestUtility *>(user_data);
+       instance->mLanguageChanged = true;
+}
+
 void VcMgrTestUtility::GetTestPCMData()
 {
        const char* pcm_path = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.vc-unittests/res/test_pcm.dat");
@@ -206,6 +213,15 @@ bool VcMgrTestUtility::IsSpeechDetected(int duration)
        return VcCommonTestUtility::WaitCondtion(resultChecker, duration);
 }
 
+bool VcMgrTestUtility::IsLanguageChanged(int duration)
+{
+       auto resultChecker = std::bind([](VcMgrTestUtility *instance) {
+               return instance->mLanguageChanged;
+       }, this);
+
+       return VcCommonTestUtility::WaitCondtion(resultChecker, duration);
+}
+
 bool VcMgrTestUtility::Prepare()
 {
        vc_state_e state = VC_STATE_INITIALIZED;

diff --git a/tests/src/vc_mgr_test_util.h b/tests/src/vc_mgr_test_util.h
index 2d8dd92..c0db4ad 100644 (file)
--- a/tests/src/vc_mgr_test_util.h
+++ b/tests/src/vc_mgr_test_util.h
@@ -31,6 +31,7 @@ public:
        static bool AllResultCallback(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char *result, const char *msg, void *user_data);
        static void ResultCallback(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, void *user_data);
        static void SpeechDetectedCallback(void *user_data);
+       static void LanguageChangedCallback(const char* previous, const char* current, void* user_data);
 
 public:
        VcMgrTestUtility();
@@ -58,6 +59,7 @@ public:
        bool IsAllResultReceived(int duration);
        bool IsResultReceived(int duration);
        bool IsSpeechDetected(int duration);
+       bool IsLanguageChanged(int duration);
 
 public:
        vc_state_e mCurrentState;
@@ -70,6 +72,7 @@ public:
        int mSetSelectedResultReturn;
        bool mResultReceived;
        bool mSpeechDetected;
+       bool mLanguageChanged;
 
        char *mErrorMessage;
 

diff --git a/tests/src/vc_mgr_unittests.cpp b/tests/src/vc_mgr_unittests.cpp
index a762bcc..833f75d 100644 (file)
--- a/tests/src/vc_mgr_unittests.cpp
+++ b/tests/src/vc_mgr_unittests.cpp
@@ -28,6 +28,7 @@
 #include "cynara_mock.h"
 
 #include "vc_common_test_util.h"
+#include "vc_test_util.h"
 #include "vc_mgr_test_util.h"
 
 
@@ -66,10 +67,6 @@ static void test_feedback_streaming_cb(vc_feedback_event_e event, char* buffer,
 {
 }
 
-static void test_current_language_changed_cb(const char* previous, const char* current, void* user_data)
-{
-}
-
 static bool test_supported_language_cb(const char* language, void* user_data)
 {
        return true;
@@ -222,6 +219,7 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_prepare_p1)
        }
 
        EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
        ASSERT_EQ(mMgrTestUtil->IsStateChanged(VC_STATE_READY, 5), true);
 }
 
@@ -264,7 +262,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unprepare_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to disconnect service engine
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unprepare_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NOT_SUPPORTED);
@@ -272,6 +270,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_n1)
        }
 
        EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -436,6 +437,19 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_p1)
 
        EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
        EXPECT_EQ(state, VC_SERVICE_STATE_READY);
+
+       mMgrTestUtil->SetDefaultCommands();
+       mMgrTestUtil->Start(false);
+       EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
+       EXPECT_EQ(state, VC_SERVICE_STATE_RECORDING);
+
+       mMgrTestUtil->Stop();
+       EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
+       EXPECT_EQ(state, VC_SERVICE_STATE_PROCESSING);
+
+       mMgrTestUtil->Cancel();
+       EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
+       EXPECT_EQ(state, VC_SERVICE_STATE_READY);
 }
 
 /**
@@ -458,7 +472,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to get current state of service engine
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_service_state_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_service_state_n2)
 {
        vc_service_state_e state;
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
@@ -467,6 +481,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_service_state_n2)
        }
 
        EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -483,7 +500,12 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_is_command_format_supported_p1)
                return;
        }
 
-       EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(VC_COMMAND_FORMAT_FIXED, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(VC_COMMAND_FORMAT_FIXED_AND_VFIXED, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(VC_COMMAND_FORMAT_VFIXED_AND_FIXED, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(VC_COMMAND_FORMAT_FIXED_AND_NONFIXED, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(VC_COMMAND_FORMAT_NONFIXED_AND_FIXED, &support), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_is_command_format_supported(10, &support), VC_ERROR_NONE);
 }
 
 /**
@@ -559,7 +581,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set command list used as candidate set
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_command_list_n2)
 {
        vc_cmd_list_h commands = nullptr;
 
@@ -572,6 +594,10 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_n2)
        ASSERT_NE(commands, nullptr);
 
        EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_INVALID_STATE);
+
        EXPECT_EQ(vc_cmd_list_destroy(commands, true), VC_ERROR_NONE);
 }
 
@@ -597,7 +623,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unset_command_list_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to unset command list used as candidate set
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_command_list_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_command_list_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NOT_SUPPORTED);
@@ -605,6 +631,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_command_list_n1)
        }
 
        EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -638,31 +667,15 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n1)
 
        EXPECT_EQ(vc_mgr_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER);
        EXPECT_EQ(vc_mgr_set_command_list_from_file(VcCommonTestUtility::GetCommandEmptyFilePath(), VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(vc_mgr_set_command_list_from_file(VcCommonTestUtility::GetCommandJsonFilePath(), -1), VC_ERROR_INVALID_PARAMETER);
 }
 
 /**
  * @testcase           utc_vc_mgr_set_command_list_from_file_n2
  * @since_tizen                5.0
- * @description                Negative UTC to unset command list from file used as candidate set
- */
-TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n2)
-{
-       const char *filePath = VcCommonTestUtility::GetCommandJsonFilePath();
-
-       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_set_command_list_from_file(filePath, -1), VC_ERROR_NOT_SUPPORTED);
-               return;
-       }
-
-       EXPECT_EQ(vc_mgr_set_command_list_from_file(filePath, -1), VC_ERROR_INVALID_PARAMETER);
-}
-
-/**
- * @testcase           utc_vc_mgr_set_command_list_from_file_n3
- * @since_tizen                5.0
- * @description                Negative UTC to unset command list from file used as candidate set
+ * @description                Negative UTC to unset command list from file used as candidate set (Invalid state)
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n3)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_command_list_from_file_n2)
 {
        const char *filePath = VcCommonTestUtility::GetCommandJsonFilePath();
 
@@ -672,6 +685,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n3)
        }
 
        EXPECT_EQ(vc_mgr_set_command_list_from_file(filePath, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_command_list_from_file(filePath, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -707,11 +723,11 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_preloaded_commands_from_file_n1)
 }
 
 /**
- * @testcase           utc_vc_mgr_set_command_list_from_file_n2
+ * @testcase           utc_vc_mgr_set_preloaded_commands_from_file_n2
  * @since_tizen                5.0
  * @description                Negative UTC to unset command list from file used as candidate set
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_preloaded_commands_from_file_n2)
 {
        const char *filePath = VcCommonTestUtility::GetCommandJsonFilePath();
 
@@ -721,6 +737,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(filePath), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(filePath), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -761,7 +780,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_current_commands_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to get command of current pointer
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_commands_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_current_commands_n2)
 {
        vc_cmd_list_h commands = nullptr;
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
@@ -770,6 +789,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_commands_n2)
        }
 
        EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -808,7 +830,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_audio_type_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set audio type
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_type_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_audio_type_n2)
 {
        const char *audioType = "audio_id";
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
@@ -817,6 +839,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_type_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -856,7 +881,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_audio_type_n1)
  * @since_tizen                5.0
  * @description                Positive UTC to get audio type
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_audio_type_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_audio_type_n2)
 {
        char *audioType = nullptr;
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
@@ -865,6 +890,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_audio_type_n2)
        }
 
        EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -902,7 +930,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_recognition_mode_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set recognition mode
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_recognition_mode_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_recognition_mode_n2)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NOT_SUPPORTED);
@@ -910,6 +938,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_recognition_mode_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -1001,7 +1032,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_private_data_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set private data
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_private_data_n2)
 {
        const char *key = "key";
        const char *data = "data";
@@ -1011,6 +1042,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -1054,7 +1088,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_private_data_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to get private data
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_private_data_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_private_data_n2)
 {
        const char *key = "key";
        char *data = nullptr;
@@ -1064,6 +1098,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_private_data_n2)
        }
 
        EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -1108,7 +1145,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_do_action_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to requesting the do action
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_do_action_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_do_action_n2)
 {
        char *event = strdup("send_event");
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
@@ -1117,6 +1154,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_do_action_n2)
        }
 
        EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -1135,6 +1175,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_p1)
        }
 
        EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NONE);
+       // EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, nullptr), VC_ERROR_NONE);
 }
 
 /**
@@ -1161,7 +1202,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to send specific engine request
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_send_specific_engine_request_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_send_specific_engine_request_n2)
 {
        const char* engineAppId = DEFAULT_ENGINE_APP_ID;
        const char* event = "event";
@@ -1172,6 +1213,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_send_specific_engine_request_n2)
        }
 
        EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -1198,34 +1242,26 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to start about voice control manager
  */
-TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_start_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       mMgrTestUtil->SetDefaultCommands();
-       mMgrTestUtil->Start(false);
-
        EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
 
-       mMgrTestUtil->Cancel();
-}
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
 
-/**
- * @testcase           utc_vc_mgr_start_n2
- * @since_tizen                5.0
- * @description                Negative UTC to start about voice control manager
- */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_start_n2)
-{
-       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
-               return;
-       }
+       mMgrTestUtil->Prepare();
+       mMgrTestUtil->SetDefaultCommands();
+       EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_start(false), VC_ERROR_IN_PROGRESS_TO_RECORDING);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_RECORDING, 5), true);
 
        EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
+       mMgrTestUtil->Cancel();
 }
 
 /**
@@ -1254,35 +1290,34 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to stop about voice control manager
  */
-TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_stop_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       mMgrTestUtil->SetDefaultCommands();
-       mMgrTestUtil->Start(false);
-       mMgrTestUtil->Stop();
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
 
+       mMgrTestUtil->Initialize();
        EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
 
-       mMgrTestUtil->Cancel();
-}
+       mMgrTestUtil->Prepare();
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
 
-/**
- * @testcase           utc_vc_mgr_stop_n2
- * @since_tizen                5.0
- * @description                Negative UTC to stop about voice control manager
- */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_stop_n2)
-{
-       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
-               return;
-       }
+       mMgrTestUtil->SetDefaultCommands();
+       mMgrTestUtil->Start(false);
 
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_IN_PROGRESS_TO_PROCESSING);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_PROCESSING, 5), true);
        EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_READY, 5), true);
+
+       mMgrTestUtil->Start(false);
+       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_IN_PROGRESS_TO_READY);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_READY, 5), true);
 }
 
 /**
@@ -1309,15 +1344,28 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to cancel about voice control manager
  */
-TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_cancel_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
+       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Prepare();
        mMgrTestUtil->SetDefaultCommands();
-       mMgrTestUtil->Start(false);
+       EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_IN_PROGRESS_TO_RECORDING);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_RECORDING, 5), true);
+
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_IN_PROGRESS_TO_PROCESSING);
+       EXPECT_EQ(mMgrTestUtil->IsServiceStateChanged(VC_SERVICE_STATE_PROCESSING, 5), true);
+       EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
 
        EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
        EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_IN_PROGRESS_TO_READY);
@@ -1325,24 +1373,6 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_n1)
 }
 
 /**
- * @testcase           utc_vc_mgr_cancel_n2
- * @since_tizen                5.0
- * @description                Negative UTC to cancel about voice control manager
- */
-TEST_F(VcMgrTestInNoneState, utc_vc_mgr_cancel_n2)
-{
-       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
-               return;
-       }
-
-       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
-
-       mMgrTestUtil->Initialize();
-       EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
-}
-
-/**
  * @testcase           utc_vc_mgr_get_recording_volume_p1
  * @since_tizen                5.0
  * @description                Positive UTC to get recording volume
@@ -2045,11 +2075,29 @@ TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_speech_detected_cb_n1)
 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_p1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_set_current_language_changed_cb(test_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+               EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(test_current_language_changed_cb, nullptr), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_vc_mgr_set_current_language_changed_cb_p2
+ * @since_tizen                5.0
+ * @description                Positive UTC to set current language changed callback
+ */
+TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_p2)
+{
+       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
+               EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_NONE);
+
+       VcCommonTestUtility::SetCurrentLanguage("ko_KR");
+       EXPECT_EQ(mMgrTestUtil->IsLanguageChanged(5), true);
 }
 
 /**
@@ -2070,20 +2118,20 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_n
 /**
  * @testcase           utc_vc_mgr_set_current_language_changed_cb_n2
  * @since_tizen                5.0
- * @description                Negative UTC to set current language changed callback
+ * @description                Negative UTC to set current language changed callback (Invalid state)
  */
 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_current_language_changed_cb_n2)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
-               EXPECT_EQ(vc_mgr_set_current_language_changed_cb(test_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
+               EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(test_current_language_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
+       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_INVALID_STATE);
 
        mMgrTestUtil->Initialize();
        mMgrTestUtil->Prepare();
-       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(test_current_language_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
+       EXPECT_EQ(vc_mgr_set_current_language_changed_cb(mMgrTestUtil->LanguageChangedCallback, mMgrTestUtil), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -3144,6 +3192,14 @@ TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_audio_streaming_mode_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       mMgrTestUtil->Prepare();
+       mMgrTestUtil->SetDefaultCommands();
+       mMgrTestUtil->Start(false);
+
+       EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_INVALID_STATE);
+
 }
 
 /**
@@ -3193,6 +3249,53 @@ TEST_F(VcMgrTestInNoneState, utc_vc_mgr_change_background_volume_n2)
 }
 
 /**
+ * @testcase           utc_vc_mgr_change_background_volume_by_ratio_p1
+ * @since_tizen                5.0
+ * @description                Positive UTC to change background volume by ratio
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_change_background_volume_by_ratio_p1)
+{
+       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
+               EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(0.5), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(0.5), VC_ERROR_NONE);
+       EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_vc_mgr_change_background_volume_by_ratio_n1
+ * @since_tizen                5.0
+ * @description                Negative UTC to change background volume by ratio
+ */
+TEST_F(VcMgrTestInReadyState, utc_vc_mgr_change_background_volume_by_ratio_n1)
+{
+       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
+               EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(-1.0), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(-0.5), VC_ERROR_INVALID_PARAMETER);
+       EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(1.5), VC_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_vc_mgr_change_background_volume_by_ratio_n2
+ * @since_tizen                5.0
+ * @description                Negative UTC to change background volume by ratio
+ */
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_change_background_volume_by_ratio_n2)
+{
+       if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
+               EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(0.5), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_mgr_change_background_volume_by_ratio(0.5), VC_ERROR_INVALID_STATE);
+}
+
+/**
  * @testcase           utc_vc_mgr_reset_background_volume_p1
  * @since_tizen                5.0
  * @description                Positive UTC to change background volume
@@ -3316,7 +3419,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_demandable_client_rule_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set demandable client rule
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_demandable_client_rule_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_demandable_client_rule_n2)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_NOT_SUPPORTED);
@@ -3324,6 +3427,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_demandable_client_rule_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -3346,7 +3452,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unset_demandable_client_rule_p1)
  * @since_tizen                5.0
  * @description                Negative UTC to unset demandable client rule
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_demandable_client_rule_n1)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_demandable_client_rule_n1)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_NOT_SUPPORTED);
@@ -3354,6 +3460,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_demandable_client_rule_n1)
        }
 
        EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_INVALID_STATE);
 }
 
 /**
@@ -3391,7 +3500,7 @@ TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_domain_n1)
  * @since_tizen                5.0
  * @description                Negative UTC to set domain
  */
-TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_domain_n2)
+TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_domain_n2)
 {
        if (false == VcCommonTestUtility::IsVcMgrFeatureSupported()) {
                EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_NOT_SUPPORTED);
@@ -3399,6 +3508,9 @@ TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_domain_n2)
        }
 
        EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_INVALID_STATE);
+
+       mMgrTestUtil->Initialize();
+       EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_INVALID_STATE);
 }
 
 

diff --git a/tests/src/vc_test_util.cpp b/tests/src/vc_test_util.cpp
index 3788465..b150f73 100644 (file)
--- a/tests/src/vc_test_util.cpp
+++ b/tests/src/vc_test_util.cpp
@@ -27,6 +27,7 @@ VcTestUtility::VcTestUtility()
        mCurrentServiceState = VC_SERVICE_STATE_NONE;
        mErrorOccured = false;
        mResultReceived = false;
+       mLanguageChanged = false;
 
        mErrorMessage = nullptr;
 
@@ -68,6 +69,12 @@ void VcTestUtility::ResultCallback(vc_result_event_e event, vc_cmd_list_h vc_cmd
        instance->mResultReceived = true;
 }
 
+void VcTestUtility::LanguageChangedCallback(const char* previous, const char* current, void* user_data)
+{
+       auto instance = reinterpret_cast<VcTestUtility *>(user_data);
+       instance->mLanguageChanged = true;
+}
+
 void VcTestUtility::Initialize()
 {
        if (VcCommonTestUtility::IsVcFeatureSupported() == false) {
@@ -122,6 +129,15 @@ bool VcTestUtility::IsResultReceived(int duration)
        return VcCommonTestUtility::WaitCondtion(resultChecker, duration);
 }
 
+bool VcTestUtility::IsLanguageChanged(int duration)
+{
+       auto resultChecker = std::bind([](VcTestUtility *instance) {
+               return instance->mLanguageChanged;
+       }, this);
+
+       return VcCommonTestUtility::WaitCondtion(resultChecker, duration);
+}
+
 bool VcTestUtility::Prepare()
 {
        vc_state_e state = VC_STATE_INITIALIZED;

diff --git a/tests/src/vc_test_util.h b/tests/src/vc_test_util.h
index 51e94d3..4de8dc8 100644 (file)
--- a/tests/src/vc_test_util.h
+++ b/tests/src/vc_test_util.h
@@ -29,6 +29,7 @@ public:
        static void ServiceStateChangedCallback(vc_service_state_e previous, vc_service_state_e current, void* user_data);
        static void ErrorCallback(vc_error_e reason, void *user_data);
        static void ResultCallback(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, void *user_data);
+       static void LanguageChangedCallback(const char* previous, const char* current, void* user_data);
 
 public:
        VcTestUtility();
@@ -44,6 +45,7 @@ public:
        bool IsServiceStateChanged(vc_service_state_e targetState, int duration);
        bool IsErrorOccurring(int duration);
        bool IsResultReceived(int duration);
+       bool IsLanguageChanged(int duration);
 
 public:
        vc_state_e mCurrentState;
@@ -51,6 +53,7 @@ public:
 
        bool mErrorOccured;
        bool mResultReceived;
+       bool mLanguageChanged;
 
        char *mErrorMessage;
        vc_cmd_list_h mTestCommands;

diff --git a/tests/src/vc_unittests.cpp b/tests/src/vc_unittests.cpp
index 3324ac6..f529acd 100644 (file)
--- a/tests/src/vc_unittests.cpp
+++ b/tests/src/vc_unittests.cpp
@@ -38,16 +38,11 @@ static const char *TEST_INVOCATION_NAME = "invocation";
 static const char *TEST_CREDENTIAL = "credential";
 
 
-static void test_current_language_changed_cb(const char* previous, const char* current, void* user_data)
-{
-}
-
 static bool test_supported_language_cb(const char* language, void* user_data)
 {
        return true;
 }
 
-
 static void test_tts_streaming_cb(vc_tts_event_e event, char* buffer, int len, int utt_id, void *user_data)
 {
 }
@@ -783,11 +778,11 @@ TEST_F(VCTestInNoneState, utc_vc_set_command_list_from_file_n2)
 TEST_F(VCTestInReadyState, utc_vc_get_result_p1)
 {
        if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
-               EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, nullptr), VC_ERROR_NOT_SUPPORTED);
+               EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, nullptr), VC_ERROR_NONE);
+       EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, mVcTestUtil), VC_ERROR_NONE);
 }
 
 /**
@@ -806,6 +801,24 @@ TEST_F(VCTestInReadyState, utc_vc_get_result_n1)
 }
 
 /**
+ * @testcase           utc_vc_get_result_n2
+ * @since_tizen                3.0
+ * @description                Negative UTC to get the recognition result (Invalid state)
+ */
+TEST_F(VCTestInNoneState, utc_vc_get_result_n2)
+{
+       if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
+               EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, mVcTestUtil), VC_ERROR_INVALID_STATE);
+
+       mVcTestUtil->Initialize();
+       EXPECT_EQ(vc_get_result(mVcTestUtil->ResultCallback, mVcTestUtil), VC_ERROR_INVALID_STATE);
+}
+
+/**
  * @testcase           utc_vc_set_result_cb_p1
  * @since_tizen                2.4
  * @description                Positive UTC to set result callback
@@ -1062,11 +1075,32 @@ TEST_F(VCTestInNoneState, utc_vc_unset_state_changed_cb_n1)
 TEST_F(VCTest, utc_vc_set_current_language_changed_cb_p1)
 {
        if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
-               EXPECT_EQ(vc_set_current_language_changed_cb(test_current_language_changed_cb, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
+               EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_vc_set_current_language_changed_cb_p2
+ * @since_tizen                2.4
+ * @description                Positive UTC to set current language changed callback
+ */
+TEST_F(VCTest, utc_vc_set_current_language_changed_cb_p2)
+{
+       if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
+               EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       EXPECT_EQ(vc_set_current_language_changed_cb(test_current_language_changed_cb, mVcTestUtil), VC_ERROR_NONE);
+       EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_NONE);
+
+       VcCommonTestUtility::SetCurrentLanguage("en_US");
+       VcCommonTestUtility::SetCurrentLanguage("ko_KR");
+       EXPECT_EQ(mVcTestUtil->IsLanguageChanged(5), true);
+
+       VcCommonTestUtility::EnableAutoLanguageSelection();
 }
 
 /**
@@ -1092,15 +1126,15 @@ TEST_F(VCTest, utc_vc_set_current_language_changed_cb_n1)
 TEST_F(VCTestInNoneState, utc_vc_set_current_language_changed_cb_n2)
 {
        if (false == VcCommonTestUtility::IsVcFeatureSupported()) {
-               EXPECT_EQ(vc_set_current_language_changed_cb(test_current_language_changed_cb, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
+               EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       EXPECT_EQ(vc_set_current_language_changed_cb(test_current_language_changed_cb, mVcTestUtil), VC_ERROR_INVALID_STATE);
+       EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_INVALID_STATE);
 
        mVcTestUtil->Initialize();
        EXPECT_EQ(mVcTestUtil->Prepare(), true);
-       EXPECT_EQ(vc_set_current_language_changed_cb(test_current_language_changed_cb, mVcTestUtil), VC_ERROR_INVALID_STATE);
+       EXPECT_EQ(vc_set_current_language_changed_cb(mVcTestUtil->LanguageChangedCallback, mVcTestUtil), VC_ERROR_INVALID_STATE);
 }
 
 /**