Fix disabled tests and add new testfix/hmi_event_incorrect_states

2 files changed, 96 insertions, 46 deletions

diff --git a/src/components/application_manager/test/application_state_test.cc b/src/components/application_manager/test/application_state_test.cc
index 5fce8866eb..b45b078ab3 100644
--- a/src/components/application_manager/test/application_state_test.cc
+++ b/src/components/application_manager/test/application_state_test.cc
@@ -297,7 +297,7 @@ TEST_F(ApplicationStateTest, InitState_GetRegularState) {
   EXPECT_EQ(initial_state_, curr_state);
 }
 
-TEST_F(ApplicationStateTest, AddPosponedState_DeletePosponedState) {
+TEST_F(ApplicationStateTest, AddPostponedState_DeletePosponedState) {
   // Precondition
   StateID init_state = StateID::STATE_ID_REGULAR;
   initial_state_ = std::make_shared<HmiState>(
diff --git a/src/components/application_manager/test/state_controller/state_controller_test.cc b/src/components/application_manager/test/state_controller/state_controller_test.cc
index f996764e18..4de653ae68 100644
--- a/src/components/application_manager/test/state_controller/state_controller_test.cc
+++ b/src/components/application_manager/test/state_controller/state_controller_test.cc
@@ -238,6 +238,7 @@ class StateControllerImplTest : public ::testing::Test {
   std::vector<am::HmiStatePtr> invalid_states_for_not_audio_app;
   std::vector<am::HmiStatePtr> invalid_states_for_audio_app;
   std::vector<am::HmiState::StateID> valid_state_ids_;
+  std::vector<am::HmiState::StateID> valid_non_navi_state_ids_;
 
   typedef std::map<am::ApplicationSharedPtr,
                    NiceMock<application_manager_test::MockApplication>*>
@@ -524,7 +525,7 @@ class StateControllerImplTest : public ::testing::Test {
                            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
             createHmiState(HMILevel::HMI_LIMITED,
-                           AudioStreamingState::ATTENUATED,
+                           AudioStreamingState::NOT_AUDIBLE,
                            VideoStreamingState::NOT_STREAMABLE,
                            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
@@ -543,6 +544,10 @@ class StateControllerImplTest : public ::testing::Test {
         result_hmi_state = valid_states_for_audio_app_;
         break;
       }
+      case APP_TYPE_ATTENUATED: {
+        PrepareStateResultsForAttenuated(result_hmi_state);
+        break;
+      }
       default: { break; }
     }
   }
@@ -914,6 +919,12 @@ class StateControllerImplTest : public ::testing::Test {
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_PHONE_CALL);
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_SAFETY_MODE);
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_NAVI_STREAMING);
+
+    valid_non_navi_state_ids_.push_back(am::HmiState::StateID::STATE_ID_VR_SESSION);
+    valid_non_navi_state_ids_.push_back(am::HmiState::StateID::STATE_ID_TTS_SESSION);
+    valid_non_navi_state_ids_.push_back(am::HmiState::StateID::STATE_ID_PHONE_CALL);
+    valid_non_navi_state_ids_.push_back(
+        am::HmiState::StateID::STATE_ID_SAFETY_MODE);
   }
 
   void ConfigureApps() {
@@ -1224,6 +1235,13 @@ class StateControllerImplTest : public ::testing::Test {
                           mobile_apis::SystemContext::SYSCTXT_MAIN);
   }
 
+  am::HmiStatePtr FullAudibleStreamableState() {
+    return createHmiState(mobile_apis::HMILevel::HMI_FULL,
+                          mobile_apis::AudioStreamingState::AUDIBLE,
+                          mobile_apis::VideoStreamingState::STREAMABLE,
+                          mobile_apis::SystemContext::SYSCTXT_MAIN);
+  }
+
   am::HmiStatePtr FullNotAudibleState() {
     return createHmiState(mobile_apis::HMILevel::HMI_FULL,
                           mobile_apis::AudioStreamingState::NOT_AUDIBLE,
@@ -2199,8 +2217,7 @@ TEST_F(StateControllerImplTest,
       media_navi_vc_app_, kDefaultWindowId, FullAudibleState(), false);
 }
 
-// TODO {AKozoriz} Changed logic in state_controller
-TEST_F(StateControllerImplTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
+TEST_F(StateControllerImplTest, ActivateAppSuccessReceivedFromHMI) {
   using namespace hmi_apis;
   using namespace mobile_apis;
 
@@ -2342,16 +2359,16 @@ TEST_F(StateControllerImplTest, ActivateAppInvalidCorrelationId) {
   state_ctrl_->on_event(event);
 }
 
-TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForSimpleApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForSimpleApp) {
   InsertApplication(simple_app_);
   CheckStateApplyingForApplication(
-      simple_app_, *simple_app_ptr_, valid_state_ids_);
+      simple_app_, *simple_app_ptr_, valid_non_navi_state_ids_);
 }
 
-TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForMediaApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaApp) {
   InsertApplication(media_app_);
   CheckStateApplyingForApplication(
-      media_app_, *media_app_ptr_, valid_state_ids_);
+      media_app_, *media_app_ptr_, valid_non_navi_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) {
@@ -2359,9 +2376,10 @@ TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) {
   CheckStateApplyingForApplication(navi_app_, *navi_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForVCApp) {
   InsertApplication(vc_app_);
-  CheckStateApplyingForApplication(vc_app_, *vc_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      vc_app_, *vc_app_ptr_, valid_non_navi_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) {
@@ -2370,10 +2388,10 @@ TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) {
       media_navi_app_, *media_navi_app_ptr_, valid_state_ids_);
 }
 
-TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForMediaVCApp) {
+TEST_F(StateControllerImplTest, ApplyTempStatesForMediaVCApp) {
   InsertApplication(media_vc_app_);
   CheckStateApplyingForApplication(
-      media_vc_app_, *media_vc_app_ptr_, valid_state_ids_);
+      media_vc_app_, *media_vc_app_ptr_, valid_non_navi_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForNaviVCApp) {
@@ -2515,82 +2533,80 @@ TEST_F(StateControllerImplTest,
 }
 
 TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(simple_app_,
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(simple_app_,
                                                    app_manager_mock_);
   TestSetState(simple_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_NON_MEDIA,
                &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
 TEST_F(StateControllerImplTest,
-       DISABLED_SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(media_app_,
-                                                   app_manager_mock_);
+       SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(media_app_,
+                                                  app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(media_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_MEDIA,
                &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
 TEST_F(StateControllerImplTest,
-       DISABLED_SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(media_app_,
-                                                   app_manager_mock_);
+       SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(media_app_,
+                                                  app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(media_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_ATTENUATED,
-               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
 TEST_F(StateControllerImplTest,
-       DISABLED_SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_);
+       SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(vc_app_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
   TestSetState(vc_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_MEDIA,
                &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
 TEST_F(StateControllerImplTest,
-       DISABLED_SetNaviStreamingStateVCApplicationAttenuatedSupported) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_);
+       SetNaviStreamingStateVCApplicationAttenuatedSupported) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(vc_app_, app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
   TestSetState(vc_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_ATTENUATED,
-               &StateControllerImplTest::PrepareVRTTSHMIStateResults);
+               &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerImplTest, DISABLED_SetNaviStreamingStateNaviApplication) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(navi_app_,
-                                                   app_manager_mock_);
+TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(navi_app_, app_manager_mock_);
   TestSetState(navi_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_NAVI,
                &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
 
-TEST_F(StateControllerImplTest,
-       DISABLED_SetNaviStreamingStateMediaNaviApplication) {
-  am::HmiStatePtr state_navi_streming =
-      std::make_shared<am::VideoStreamingHmiState>(media_navi_app_,
-                                                   app_manager_mock_);
+TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) {
+  am::HmiStatePtr state_navi_streaming =
+      std::make_shared<am::NaviStreamingHmiState>(media_navi_app_,
+                                                  app_manager_mock_);
   TestSetState(media_navi_app_,
-               state_navi_streming,
+               state_navi_streaming,
                APP_TYPE_NAVI,
                &StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
 }
@@ -3221,6 +3237,40 @@ TEST_F(StateControllerImplTest, OnEventChangedAudioSourceAppToBackground) {
             mobile_apis::AudioStreamingState::NOT_AUDIBLE);
 }
 
+TEST_F(StateControllerImplTest, OnEventChangedAudioSourceNavAppToLimited) {
+  const uint32_t app_id = navi_app_->app_id();
+  InsertApplication(navi_app_);
+  smart_objects::SmartObject msg;
+  msg[am::strings::msg_params][am::strings::app_id] = app_id;
+  msg[am::strings::msg_params][am::hmi_notification::is_active] = true;
+  msg[am::strings::msg_params][am::hmi_notification::event_name] =
+      hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+
+  const hmi_apis::FunctionID::eType event_id =
+      hmi_apis::FunctionID::BasicCommunication_OnEventChanged;
+  am::event_engine::Event event(event_id);
+  event.set_smart_object(msg);
+
+  EXPECT_CALL(*navi_app_ptr_, is_navi()).WillRepeatedly(Return(true));
+  EXPECT_CALL(*navi_app_ptr_, CurrentHmiState(kDefaultWindowId))
+      .WillOnce(Return(FullAudibleStreamableState()));
+
+  HmiStatePtr new_state;
+  EXPECT_CALL(*navi_app_ptr_, AddHMIState(kDefaultWindowId, _))
+      .WillOnce(SaveArg<1>(&new_state));
+
+  am::WindowIds window_ids = {kDefaultWindowId};
+  EXPECT_CALL(*navi_app_ptr_, GetWindowIds()).WillOnce(Return(window_ids));
+
+  state_ctrl_->on_event(event);
+
+  EXPECT_EQ(new_state->hmi_level(), mobile_apis::HMILevel::HMI_LIMITED);
+  EXPECT_EQ(new_state->audio_streaming_state(),
+            mobile_apis::AudioStreamingState::AUDIBLE);
+  EXPECT_EQ(new_state->video_streaming_state(),
+            mobile_apis::VideoStreamingState::STREAMABLE);
+}
+
 TEST_F(StateControllerImplTest, OnEventOnAppDeactivatedIncorrectHmiLevel) {
   smart_objects::SmartObject msg;
   const uint32_t app_id = simple_app_->app_id();