diff options
Diffstat (limited to 'src/components/application_manager/test/state_controller/state_controller_test.cc')
| -rw-r--r-- | src/components/application_manager/test/state_controller/state_controller_test.cc | 2026 |
1 files changed, 1513 insertions, 513 deletions
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 488d12b502..f19a0896d1 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 @@ -30,21 +30,35 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include <gtest/gtest.h> +#include "gtest/gtest.h" #include "application_manager/hmi_state.h" -#include "application_manager/state_controller.h" +#include "application_manager/state_controller_impl.h" #include "application_manager/usage_statistics.h" -#include "application_manager_mock.h" -#include "application_mock.h" -#include "statistics_manager_mock.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/mock_application.h" +#include "connection_handler/mock_connection_handler_settings.h" +#include "connection_handler/connection_handler_impl.h" +#include "transport_manager/mock_transport_manager.h" +#include "application_manager/statistics_manager_mock.h" #include "utils/lock.h" #include "utils/data_accessor.h" #include "utils/make_shared.h" #include "application_manager/message_helper.h" #include "application_manager/event_engine/event.h" #include "application_manager/smart_object_keys.h" +#include "application_manager/mock_message_helper.h" +#include "policy/mock_policy_settings.h" +#include "protocol_handler/mock_session_observer.h" +#include "connection_handler/mock_connection_handler.h" +#include "application_manager/policies/mock_policy_handler_interface.h" +#include "application_manager/mock_event_dispatcher.h" +#include "application_manager/resumption/resume_ctrl.h" +#include "application_manager/mock_application_manager.h" namespace am = application_manager; +using am::HmiState; +using am::HmiStatePtr; +using am::UsageStatistics; using ::testing::_; using ::testing::Return; using ::testing::ReturnRef; @@ -53,30 +67,12 @@ using ::testing::Mock; using ::testing::NiceMock; using ::testing::InSequence; using ::testing::Truly; +using ::testing::AtLeast; -class MessageHelperMock { - public: - MOCK_METHOD3(SendActivateAppToHMI, - uint32_t(uint32_t const app_id, - hmi_apis::Common_HMILevel::eType level, - bool send_policy_priority)); - MOCK_METHOD1(SendOnResumeAudioSourceToHMI, void(const uint32_t app_id)); -}; - -static MessageHelperMock* message_helper_mock_; - -uint32_t application_manager::MessageHelper::SendActivateAppToHMI( - uint32_t const app_id, hmi_apis::Common_HMILevel::eType level, - bool send_policy_priority) { - return message_helper_mock_->SendActivateAppToHMI(app_id, level, - send_policy_priority); -} - -void application_manager::MessageHelper::SendOnResumeAudioSourceToHMI( - const uint32_t app_id) { - message_helper_mock_->SendOnResumeAudioSourceToHMI(app_id); -} +static application_manager::MockMessageHelper* message_helper_mock_; +namespace test { +namespace components { namespace state_controller_test { struct HmiStatesComparator { @@ -88,14 +84,14 @@ struct HmiStatesComparator { mobile_apis::HMILevel::eType hmi_level, mobile_apis::AudioStreamingState::eType audio_streaming_state, mobile_apis::SystemContext::eType system_context) - : hmi_level_(hmi_level), - audio_streaming_state_(audio_streaming_state), - system_context_(system_context) {} + : hmi_level_(hmi_level) + , audio_streaming_state_(audio_streaming_state) + , system_context_(system_context) {} HmiStatesComparator(am::HmiStatePtr state_ptr) - : hmi_level_(state_ptr->hmi_level()), - audio_streaming_state_(state_ptr->audio_streaming_state()), - system_context_(state_ptr->system_context()) {} + : hmi_level_(state_ptr->hmi_level()) + , audio_streaming_state_(state_ptr->audio_streaming_state()) + , system_context_(state_ptr->system_context()) {} bool operator()(am::HmiStatePtr state_ptr) const { return state_ptr->hmi_level() == hmi_level_ && @@ -107,8 +103,7 @@ struct HmiStatesComparator { struct HmiStatesIDComparator { am::HmiState::StateID state_id_; - HmiStatesIDComparator(am::HmiState::StateID state_id) - : state_id_(state_id) {} + HmiStatesIDComparator(am::HmiState::StateID state_id) : state_id_(state_id) {} bool operator()(am::HmiStatePtr state_ptr) const { return state_ptr->state_id() == state_id_; @@ -122,53 +117,66 @@ struct HmiStatesIDComparator { #define NAVI true #define NOT_NAVI false -class StateControllerTest : public ::testing::Test { +enum ApplicationType { + APP_TYPE_NON_MEDIA, + APP_TYPE_NAVI, + APP_TYPE_MEDIA, + APP_TYPE_ATTENUATED +}; + +class StateControllerImplTest : public ::testing::Test { public: - StateControllerTest() - : ::testing::Test(), - usage_stat("0", utils::SharedPtr<us::StatisticsManager>( - new StatisticsManagerMock)), - applications_(application_set_, applications_lock_), - state_ctrl_(&app_manager_mock_) {} - NiceMock<ApplicationManagerMock> app_manager_mock_; + StateControllerImplTest() + : ::testing::Test() + , usage_stat("0", + utils::SharedPtr<usage_statistics::StatisticsManager>( + + new state_controller_test::MockStatisticsManager)) + , applications_(application_set_, applications_lock_) {} + NiceMock<application_manager_test::MockApplicationManager> app_manager_mock_; + NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_; + NiceMock<connection_handler_test::MockConnectionHandler> + mock_connection_handler_; + NiceMock<protocol_handler_test::MockSessionObserver> mock_session_observer_; am::UsageStatistics usage_stat; + NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_; am::ApplicationSet application_set_; mutable sync_primitives::Lock applications_lock_; DataAccessor<am::ApplicationSet> applications_; - am::StateController state_ctrl_; + utils::SharedPtr<am::StateControllerImpl> state_ctrl_; am::ApplicationSharedPtr simple_app_; - NiceMock<ApplicationMock>* simple_app_ptr_; + NiceMock<application_manager_test::MockApplication>* simple_app_ptr_; uint32_t simple_app_id_ = 1721; am::ApplicationSharedPtr navi_app_; - NiceMock<ApplicationMock>* navi_app_ptr_; + NiceMock<application_manager_test::MockApplication>* navi_app_ptr_; uint32_t navi_app_id_ = 1762; am::ApplicationSharedPtr media_app_; - NiceMock<ApplicationMock>* media_app_ptr_; + NiceMock<application_manager_test::MockApplication>* media_app_ptr_; uint32_t media_app_id_ = 1801; am::ApplicationSharedPtr vc_app_; - NiceMock<ApplicationMock>* vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* vc_app_ptr_; uint32_t vc_app_id_ = 1825; am::ApplicationSharedPtr media_navi_app_; - NiceMock<ApplicationMock>* media_navi_app_ptr_; + NiceMock<application_manager_test::MockApplication>* media_navi_app_ptr_; uint32_t media_navi_app_id_ = 1855; am::ApplicationSharedPtr media_vc_app_; - NiceMock<ApplicationMock>* media_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* media_vc_app_ptr_; uint32_t media_vc_app_id_ = 1881; am::ApplicationSharedPtr navi_vc_app_; - NiceMock<ApplicationMock>* navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* navi_vc_app_ptr_; uint32_t navi_vc_app_id_ = 1894; am::ApplicationSharedPtr media_navi_vc_app_; - NiceMock<ApplicationMock>* media_navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* media_navi_vc_app_ptr_; uint32_t media_navi_vc_app_id_ = 1922; std::vector<am::HmiStatePtr> valid_states_for_audio_app_; @@ -177,6 +185,12 @@ class StateControllerTest : 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::ApplicationSharedPtr> applications_list_; + + connection_handler_test::MockConnectionHandlerSettings + mock_connection_handler__settings; + transport_manager_test::MockTransportManager mock_transport_manager; + connection_handler::ConnectionHandlerImpl* conn_handler; am::HmiStatePtr createHmiState( mobile_apis::HMILevel::eType hmi_level, @@ -187,18 +201,382 @@ class StateControllerTest : public ::testing::Test { namespace SystemContext = mobile_apis::SystemContext; am::HmiStatePtr state = - utils::MakeShared<am::HmiState>(simple_app_id_, &app_manager_mock_); + utils::MakeShared<am::HmiState>(simple_app_id_, app_manager_mock_); state->set_hmi_level(hmi_level); state->set_audio_streaming_state(aidio_ss); state->set_system_context(system_context); return state; } + /** + * @brief Prepare list of resultant HMI states for testing HMIState + * @param result_hmi state will contain resultant HMI states. + */ + void PrepareCommonStateResults( + std::vector<am::HmiStatePtr>& result_hmi_state) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + result_hmi_state.push_back(createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_VRSESSION)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MENU)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_HMI_OBSCURED)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_ALERT)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + } + + /** + * @brief Prepare list of resultant HMI states for testing HMIState, for + * case when SDL supports attenuated mode + * @param result_hmi state will contain resultant HMI states. + */ + void PrepareStateResultsForAttenuated( + std::vector<am::HmiStatePtr>& result_hmi_state) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::ATTENUATED, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::ATTENUATED, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back(createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::ATTENUATED, + SystemContext::SYSCTXT_MAIN)); + } + + /** + * @brief Prepare list of resultant HMI states for testing HMIState, for + * case if phone call mode is active + * @param result_hmi state will contain resultant HMI states. + */ + void PreparePhoneCallHMIStateResults( + std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + + switch (app_t) { + case APP_TYPE_NON_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_NAVI: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + default: { break; } + } + } + + /** + * @brief Prepare list of resultant HMI states for testing HMIState, for + * case if VR or TTS mode is active + * @param result_hmi state will contain resultant HMI states. + */ + void PrepareVRTTSHMIStateResults( + std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + switch (app_t) { + case APP_TYPE_NON_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_MEDIA: + case APP_TYPE_NAVI: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_ATTENUATED: { + PrepareStateResultsForAttenuated(result_hmi_state); + break; + } + default: { break; } + } + } + + /** + * @brief Prepare list of resultant HMI states for testing HMIState, for + * case if navi streaming mode is active + * @param result_hmi state will contain resultant HMI states. + */ + void PrepareNaviStreamingHMIStateResults( + std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + switch (app_t) { + case APP_TYPE_NON_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::ATTENUATED, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_NAVI: { + result_hmi_state = valid_states_for_audio_app_; + break; + } + default: { break; } + } + } + + /** + * @brief Prepare list of resultant HMI states for testing HMIState, for + * case if navi streaming mode and TTS mode are active and SDL supports + * attenuated mode + * @param result_hmi state will contain resultant HMI states. + */ + void PrepareNaviStreamTTSStateResult( + std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) { + namespace HMILevel = mobile_apis::HMILevel; + namespace AudioStreamingState = mobile_apis::AudioStreamingState; + namespace SystemContext = mobile_apis::SystemContext; + switch (app_t) { + case APP_TYPE_NON_MEDIA: { + PrepareCommonStateResults(result_hmi_state); + result_hmi_state.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + break; + } + case APP_TYPE_MEDIA: + case APP_TYPE_NAVI: { + PrepareStateResultsForAttenuated(result_hmi_state); + break; + } + default: { break; } + } + } + + ApplicationType AppType(uint32_t app_id) { + // TODO(AOleynik): Currently there is ongoing discussion regarding mixed + // application properties, i.e. is_media_application flag from RAI and + // AppHMITypes (NAVIGATION, etc.). Most likely logic should be changed + // after conclusion on APPLINK-20231 + std::vector<am::ApplicationSharedPtr>::iterator app = std::find_if( + applications_list_.begin(), + applications_list_.end(), + [app_id](am::ApplicationSharedPtr a) { return app_id == a->app_id(); }); + + if (app == applications_list_.end()) { + return APP_TYPE_NON_MEDIA; + } + + if ((*app)->is_navi()) { + return APP_TYPE_NAVI; + } + if ((*app)->is_media_application()) { + return APP_TYPE_MEDIA; + } + return APP_TYPE_NON_MEDIA; + } + + void TestSetState(am::ApplicationSharedPtr app, + am::HmiStatePtr hmi_state, + ApplicationType app_t, + void (StateControllerImplTest::*call_back)( + std::vector<am::HmiStatePtr>&, ApplicationType)) { + InsertApplication(app); + std::vector<am::HmiStatePtr> result_hmi_state; + (this->*call_back)(result_hmi_state, app_t); + std::vector<am::HmiStatePtr>::iterator it_begin; + std::vector<am::HmiStatePtr>::iterator it_end; + if (APP_TYPE_NON_MEDIA == app_t) { + it_begin = valid_states_for_not_audio_app_.begin(); + it_end = valid_states_for_not_audio_app_.end(); + ASSERT_TRUE(result_hmi_state.size() == + valid_states_for_not_audio_app_.size()); + } else { + it_begin = valid_states_for_audio_app_.begin(); + it_end = valid_states_for_audio_app_.end(); + ASSERT_TRUE(result_hmi_state.size() == + valid_states_for_audio_app_.size()); + } + std::vector<am::HmiStatePtr>::iterator it_result_begin = + result_hmi_state.begin(); + for (; it_begin != it_end; ++it_begin, ++it_result_begin) { + hmi_state->set_parent(*it_begin); + HmiStatesComparator st_comp(hmi_state); + ASSERT_TRUE(st_comp(*it_result_begin)); + } + } + + void TestSetSeveralState( + am::ApplicationSharedPtr app, + am::HmiStatePtr first_hmi_state, + am::HmiStatePtr second_hmi_state, + ApplicationType app_t, + void (StateControllerImplTest::*call_back)(std::vector<am::HmiStatePtr>&, + ApplicationType)) { + InsertApplication(app); + std::vector<am::HmiStatePtr> result_hmi_state; + (this->*call_back)(result_hmi_state, app_t); + std::vector<am::HmiStatePtr>::iterator it_begin; + std::vector<am::HmiStatePtr>::iterator it_end; + if (APP_TYPE_NON_MEDIA == app_t) { + it_begin = valid_states_for_not_audio_app_.begin(); + it_end = valid_states_for_not_audio_app_.end(); + ASSERT_TRUE(result_hmi_state.size() == + valid_states_for_not_audio_app_.size()); + } else { + it_begin = valid_states_for_audio_app_.begin(); + it_end = valid_states_for_audio_app_.end(); + ASSERT_TRUE(result_hmi_state.size() == + valid_states_for_audio_app_.size()); + } + std::vector<am::HmiStatePtr>::iterator it_result_begin = + result_hmi_state.begin(); + for (; it_begin != it_end; ++it_begin, ++it_result_begin) { + first_hmi_state->set_parent(*it_begin); + second_hmi_state->set_parent(first_hmi_state); + HmiStatesComparator st_comp(second_hmi_state); + ASSERT_TRUE(st_comp(*it_result_begin)) + << second_hmi_state->audio_streaming_state() << "." + << second_hmi_state->hmi_level() << "." + << second_hmi_state->system_context() << "_" + << (*it_result_begin)->audio_streaming_state() << "." + << (*it_result_begin)->hmi_level() << "." + << (*it_result_begin)->system_context() << "_"; + } + } + + template <typename T, typename Q> + void TestMixState(void (StateControllerImplTest::*call_back_result)( + std::vector<am::HmiStatePtr>&, ApplicationType)) { + std::vector<am::ApplicationSharedPtr>::iterator it_begin = + applications_list_.begin(); + std::vector<am::ApplicationSharedPtr>::iterator it_end = + applications_list_.end(); + ApplicationType app_type; + uint32_t app_id; + am::ApplicationSharedPtr app; + for (; it_begin != it_end; ++it_begin) { + app_id = (*it_begin)->app_id(); + app_type = AppType(app_id); + app = (*it_begin); + am::HmiStatePtr state_first = + utils::MakeShared<T>(app_id, app_manager_mock_); + am::HmiStatePtr state_second = + utils::MakeShared<Q>(app_id, app_manager_mock_); + TestSetSeveralState( + app, state_first, state_second, app_type, call_back_result); + TestSetSeveralState( + app, state_second, state_first, app_type, call_back_result); + } + } + protected: - am::ApplicationSharedPtr ConfigureApp(NiceMock<ApplicationMock>** app_mock, - uint32_t app_id, bool media, bool navi, - bool vc) { - *app_mock = new NiceMock<ApplicationMock>; + am::ApplicationSharedPtr ConfigureApp( + NiceMock<application_manager_test::MockApplication>** app_mock, + uint32_t app_id, + bool media, + bool navi, + bool vc) { + *app_mock = new NiceMock<application_manager_test::MockApplication>; Mock::AllowLeak(*app_mock); // WorkAround for gogletest bug am::ApplicationSharedPtr app(*app_mock); @@ -222,114 +600,146 @@ class StateControllerTest : public ::testing::Test { namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; // Valid states for not audio app - message_helper_mock_ = new MessageHelperMock; + message_helper_mock_ = + application_manager::MockMessageHelper::message_helper_mock(); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MAIN)); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_VRSESSION)); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MENU)); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_HMI_OBSCURED)); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_ALERT)); - valid_states_for_not_audio_app_.push_back(createHmiState( - HMILevel::HMI_BACKGROUND, AudioStreamingState::NOT_AUDIBLE, - SystemContext::SYSCTXT_MAIN)); valid_states_for_not_audio_app_.push_back( - createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + valid_states_for_not_audio_app_.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MAIN)); // Valid states audio app valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MAIN)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_VRSESSION)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MENU)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_HMI_OBSCURED)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_ALERT)); - valid_states_for_audio_app_.push_back(createHmiState( - HMILevel::HMI_BACKGROUND, AudioStreamingState::NOT_AUDIBLE, - SystemContext::SYSCTXT_MAIN)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::NOT_AUDIBLE, SystemContext::SYSCTXT_MAIN)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::ATTENUATED, + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); valid_states_for_audio_app_.push_back( - createHmiState(HMILevel::HMI_FULL, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + valid_states_for_audio_app_.push_back( + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); // Common Invalid States common_invalid_states_.push_back( - createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + common_invalid_states_.push_back( + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::INVALID_ENUM, SystemContext::SYSCTXT_MAIN)); common_invalid_states_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::INVALID_ENUM, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::INVALID_ENUM)); + common_invalid_states_.push_back( + createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::INVALID_ENUM, SystemContext::SYSCTXT_MAIN)); common_invalid_states_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::INVALID_ENUM, SystemContext::INVALID_ENUM)); - common_invalid_states_.push_back(createHmiState( - HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::SYSCTXT_MAIN)); common_invalid_states_.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::INVALID_ENUM, + createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::INVALID_ENUM, SystemContext::INVALID_ENUM)); - common_invalid_states_.push_back(createHmiState( - HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM)); - common_invalid_states_.push_back(createHmiState( - HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM)); + // Invalid States for audio apps invalid_states_for_audio_app.push_back( - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::NOT_AUDIBLE, + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN)); + invalid_states_for_audio_app.push_back( + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); invalid_states_for_audio_app.push_back( - createHmiState(HMILevel::HMI_BACKGROUND, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); - invalid_states_for_audio_app.push_back(createHmiState( - HMILevel::HMI_BACKGROUND, AudioStreamingState::ATTENUATED, - SystemContext::SYSCTXT_MAIN)); invalid_states_for_audio_app.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); invalid_states_for_audio_app.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::ATTENUATED, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); invalid_states_for_audio_app.push_back( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::ATTENUATED, + createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); // Invalid States for not audio apps invalid_states_for_not_audio_app.push_back( - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::ATTENUATED, + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); invalid_states_for_not_audio_app.push_back( - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_LIMITED, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); invalid_states_for_not_audio_app.push_back( - createHmiState(HMILevel::HMI_FULL, AudioStreamingState::ATTENUATED, + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::ATTENUATED, SystemContext::SYSCTXT_MAIN)); invalid_states_for_not_audio_app.push_back( - createHmiState(HMILevel::HMI_FULL, AudioStreamingState::AUDIBLE, + createHmiState(HMILevel::HMI_FULL, + AudioStreamingState::AUDIBLE, SystemContext::SYSCTXT_MAIN)); // Valid state ids @@ -341,21 +751,29 @@ class StateControllerTest : public ::testing::Test { } void ConfigureApps() { - simple_app_ = ConfigureApp(&simple_app_ptr_, simple_app_id_, NOT_MEDIA, - NOT_NAVI, NOT_VC); + simple_app_ = ConfigureApp( + &simple_app_ptr_, simple_app_id_, NOT_MEDIA, NOT_NAVI, NOT_VC); media_app_ = ConfigureApp(&media_app_ptr_, media_app_id_, MEDIA, NOT_NAVI, NOT_VC); navi_app_ = ConfigureApp(&navi_app_ptr_, navi_app_id_, NOT_MEDIA, NAVI, NOT_VC); vc_app_ = ConfigureApp(&vc_app_ptr_, vc_app_id_, NOT_MEDIA, NOT_NAVI, VC); - media_navi_app_ = ConfigureApp(&media_navi_app_ptr_, media_navi_app_id_, - MEDIA, NAVI, NOT_VC); + media_navi_app_ = ConfigureApp( + &media_navi_app_ptr_, media_navi_app_id_, MEDIA, NAVI, NOT_VC); media_vc_app_ = ConfigureApp(&media_vc_app_ptr_, media_vc_app_id_, MEDIA, NOT_NAVI, VC); navi_vc_app_ = ConfigureApp(&navi_vc_app_ptr_, navi_vc_app_id_, NOT_MEDIA, NAVI, VC); - media_navi_vc_app_ = ConfigureApp(&media_navi_vc_app_ptr_, - media_navi_vc_app_id_, MEDIA, NAVI, VC); + media_navi_vc_app_ = ConfigureApp( + &media_navi_vc_app_ptr_, media_navi_vc_app_id_, MEDIA, NAVI, VC); + applications_list_.push_back(simple_app_); + applications_list_.push_back(media_app_); + applications_list_.push_back(navi_app_); + applications_list_.push_back(vc_app_); + applications_list_.push_back(media_navi_app_); + applications_list_.push_back(media_vc_app_); + applications_list_.push_back(navi_vc_app_); + applications_list_.push_back(media_navi_vc_app_); } void CheckAppConfiguration() { ASSERT_EQ(simple_app_.get(), simple_app_ptr_); @@ -413,20 +831,55 @@ class StateControllerTest : public ::testing::Test { ASSERT_TRUE(media_navi_vc_app_->is_voice_communication_supported()); } - void SetUp() { + virtual void SetUp() OVERRIDE { + ON_CALL(app_manager_mock_, event_dispatcher()) + .WillByDefault(ReturnRef(mock_event_dispatcher_)); + state_ctrl_ = utils::MakeShared<am::StateControllerImpl>(app_manager_mock_); + ON_CALL(app_manager_mock_, applications()) .WillByDefault(Return(applications_)); ConfigureApps(); CheckAppConfiguration(); FillStatesLists(); + SetConnection(); + } + + void TearDown() OVERRIDE { + delete conn_handler; } - void TearDown() { delete message_helper_mock_; } + void SetConnection() { + conn_handler = new connection_handler::ConnectionHandlerImpl( + mock_connection_handler__settings, mock_transport_manager); + ON_CALL(app_manager_mock_, connection_handler()) + .WillByDefault(ReturnRef(*conn_handler)); + } + + void SetBCActivateAppRequestToHMI( + const hmi_apis::Common_HMILevel::eType hmi_lvl, uint32_t corr_id) { + ON_CALL(mock_connection_handler_, get_session_observer()) + .WillByDefault(ReturnRef(mock_session_observer_)); + ON_CALL(app_manager_mock_, connection_handler()) + .WillByDefault(ReturnRef(mock_connection_handler_)); + ON_CALL(app_manager_mock_, GetPolicyHandler()) + .WillByDefault(ReturnRef(policy_interface_)); + smart_objects::SmartObjectSPtr bc_activate_app_request = + new smart_objects::SmartObject(); + (*bc_activate_app_request)[am::strings::params] + [am::strings::correlation_id] = corr_id; + ON_CALL(*message_helper_mock_, + GetBCActivateAppRequestToHMI(_, _, _, hmi_lvl, _, _)) + .WillByDefault(Return(bc_activate_app_request)); + + ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request)) + .WillByDefault(Return(true)); + } - void ExpectSuccesfullSetHmiState(am::ApplicationSharedPtr app, - NiceMock<ApplicationMock>* app_mock, - am::HmiStatePtr old_state, - am::HmiStatePtr new_state) { + void ExpectSuccesfullSetHmiState( + am::ApplicationSharedPtr app, + NiceMock<application_manager_test::MockApplication>* app_mock, + am::HmiStatePtr old_state, + am::HmiStatePtr new_state) { EXPECT_CALL(*app_mock, CurrentHmiState()) .WillOnce(Return(old_state)) .WillOnce(Return(new_state)); @@ -434,15 +887,18 @@ class StateControllerTest : public ::testing::Test { SetRegularState(Truly(HmiStatesComparator(new_state)))); if (!HmiStatesComparator(old_state)(new_state)) { EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(app)); - EXPECT_CALL(app_manager_mock_, - OnHMILevelChanged(app->app_id(), old_state->hmi_level(), - new_state->hmi_level())); + EXPECT_CALL( + app_manager_mock_, + OnHMILevelChanged( + app->app_id(), old_state->hmi_level(), new_state->hmi_level())); } } void ExpectAppChangeHmiStateDueToConflictResolving( - am::ApplicationSharedPtr app, NiceMock<ApplicationMock>* app_mock, - am::HmiStatePtr old_state, am::HmiStatePtr new_state) { + am::ApplicationSharedPtr app, + NiceMock<application_manager_test::MockApplication>* app_mock, + am::HmiStatePtr old_state, + am::HmiStatePtr new_state) { EXPECT_CALL(*app_mock, RegularHmiState()) .WillOnce(Return(old_state)) .WillOnce(Return(old_state)); @@ -450,7 +906,8 @@ class StateControllerTest : public ::testing::Test { } void ExpectAppWontChangeHmiStateDueToConflictResolving( - am::ApplicationSharedPtr app, NiceMock<ApplicationMock>* app_mock, + am::ApplicationSharedPtr app, + NiceMock<application_manager_test::MockApplication>* app_mock, am::HmiStatePtr state) { EXPECT_CALL(*app_mock, RegularHmiState()).WillOnce(Return(state)); EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(app)).Times(0); @@ -495,7 +952,7 @@ class StateControllerTest : public ::testing::Test { } void CheckStateApplyingForApplication( - NiceMock<ApplicationMock>& application, + NiceMock<application_manager_test::MockApplication>& application, std::vector<am::HmiState::StateID>& state_ids) { using smart_objects::SmartObject; using am::event_engine::Event; @@ -507,39 +964,43 @@ class StateControllerTest : public ::testing::Test { for (uint32_t i = 0; i < state_ids.size(); ++i) { am::HmiState::StateID state_id = state_ids[i]; EXPECT_CALL(application, - AddHMIState(Truly(HmiStatesIDComparator(state_id)))).Times(1); + AddHMIState(Truly(HmiStatesIDComparator(state_id)))).Times(1); switch (state_id) { case am::HmiState::StateID::STATE_ID_VR_SESSION: { Event vr_start_event(FunctionID::VR_Started); - state_ctrl_.on_event(vr_start_event); + state_ctrl_->on_event(vr_start_event); break; } case am::HmiState::StateID::STATE_ID_TTS_SESSION: { Event tts_start_event(FunctionID::TTS_Started); - state_ctrl_.on_event(tts_start_event); + state_ctrl_->on_event(tts_start_event); break; } case am::HmiState::StateID::STATE_ID_PHONE_CALL: { - Event phone_call_event( - FunctionID::BasicCommunication_OnPhoneCall); + Event phone_call_event(FunctionID::BasicCommunication_OnEventChanged); SmartObject message; - message[am::strings::msg_params][am::hmi_notification::is_active] = true; + message[am::strings::msg_params][am::hmi_notification::is_active] = + true; + message[am::strings::msg_params][am::hmi_notification::event_name] = + hmi_apis::Common_EventTypes::PHONE_CALL; phone_call_event.set_smart_object(message); - state_ctrl_.on_event(phone_call_event); + state_ctrl_->on_event(phone_call_event); break; } case am::HmiState::StateID::STATE_ID_SAFETY_MODE: { - Event emergency_event( - FunctionID::BasicCommunication_OnEmergencyEvent); + Event emergency_event(FunctionID::BasicCommunication_OnEventChanged); SmartObject message; - message[am::strings::msg_params][am::hmi_response::enabled] = true; + message[am::strings::msg_params][am::hmi_notification::is_active] = + true; + message[am::strings::msg_params][am::hmi_notification::event_name] = + hmi_apis::Common_EventTypes::EMERGENCY_EVENT; emergency_event.set_smart_object(message); - state_ctrl_.on_event(emergency_event); + state_ctrl_->on_event(emergency_event); break; } case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: { - state_ctrl_.OnNaviStreamingStarted(); + state_ctrl_->OnNaviStreamingStarted(); break; } default: @@ -553,37 +1014,45 @@ class StateControllerTest : public ::testing::Test { am::HmiState::StateID state_id = state_ids[i]; EXPECT_CALL(application, RemoveHMIState(state_id)).Times(1); + EXPECT_CALL(application, PostponedHmiState()) + .WillOnce(Return(NoneNotAudibleState())); + EXPECT_CALL(application, RemovePostponedState()); + switch (state_id) { case am::HmiState::StateID::STATE_ID_VR_SESSION: { Event vr_stop_event(FunctionID::VR_Stopped); - state_ctrl_.on_event(vr_stop_event); + state_ctrl_->on_event(vr_stop_event); break; } case am::HmiState::StateID::STATE_ID_TTS_SESSION: { Event tts_stop_event(FunctionID::TTS_Stopped); - state_ctrl_.on_event(tts_stop_event); + state_ctrl_->on_event(tts_stop_event); break; } case am::HmiState::StateID::STATE_ID_PHONE_CALL: { - Event phone_call_event( - FunctionID::BasicCommunication_OnPhoneCall); + Event phone_call_event(FunctionID::BasicCommunication_OnEventChanged); SmartObject message; - message[am::strings::msg_params][am::hmi_notification::is_active] = false; + message[am::strings::msg_params][am::hmi_notification::is_active] = + false; + message[am::strings::msg_params][am::hmi_notification::event_name] = + hmi_apis::Common_EventTypes::PHONE_CALL; phone_call_event.set_smart_object(message); - state_ctrl_.on_event(phone_call_event); + state_ctrl_->on_event(phone_call_event); break; } case am::HmiState::StateID::STATE_ID_SAFETY_MODE: { - Event emergency_event( - FunctionID::BasicCommunication_OnEmergencyEvent); + Event emergency_event(FunctionID::BasicCommunication_OnEventChanged); SmartObject message; - message[am::strings::msg_params][am::hmi_response::enabled] = false; + message[am::strings::msg_params][am::hmi_notification::is_active] = + false; + message[am::strings::msg_params][am::hmi_notification::event_name] = + hmi_apis::Common_EventTypes::EMERGENCY_EVENT; emergency_event.set_smart_object(message); - state_ctrl_.on_event(emergency_event); + state_ctrl_->on_event(emergency_event); break; } case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: { - state_ctrl_.OnNaviStreamingStopped(); + state_ctrl_->OnNaviStreamingStopped(); break; } default: @@ -595,37 +1064,38 @@ class StateControllerTest : public ::testing::Test { } }; -TEST_F(StateControllerTest, OnStateChangedWithEqualStates) { +TEST_F(StateControllerImplTest, OnStateChangedWithEqualStates) { EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(_)).Times(0); EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0); for (uint32_t i = 0; i < valid_states_for_not_audio_app_.size(); ++i) { - state_ctrl_.OnStateChanged(simple_app_, - valid_states_for_not_audio_app_[i], - valid_states_for_not_audio_app_[i]); + state_ctrl_->OnStateChanged(simple_app_, + valid_states_for_not_audio_app_[i], + valid_states_for_not_audio_app_[i]); } } -TEST_F(StateControllerTest, OnStateChangedWithDifferentStates) { +TEST_F(StateControllerImplTest, OnStateChangedWithDifferentStates) { for (uint32_t i = 0; i < valid_states_for_not_audio_app_.size(); ++i) { for (uint32_t j = 0; j < valid_states_for_not_audio_app_.size(); ++j) { HmiStatesComparator comp(valid_states_for_not_audio_app_[i]); if (!comp(valid_states_for_not_audio_app_[j])) { - EXPECT_CALL(app_manager_mock_, - SendHMIStatusNotification(simple_app_)).Times(1); - EXPECT_CALL(app_manager_mock_, - OnHMILevelChanged( - simple_app_id_, - valid_states_for_not_audio_app_[i]->hmi_level(), - valid_states_for_not_audio_app_[j]->hmi_level())).Times(1); + EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(simple_app_)) + .Times(1); + EXPECT_CALL( + app_manager_mock_, + OnHMILevelChanged(simple_app_id_, + valid_states_for_not_audio_app_[i]->hmi_level(), + valid_states_for_not_audio_app_[j]->hmi_level())) + .Times(1); if (mobile_apis::HMILevel::HMI_NONE == valid_states_for_not_audio_app_[j]->hmi_level()) { EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(1); } - state_ctrl_.OnStateChanged(simple_app_, - valid_states_for_not_audio_app_[i], - valid_states_for_not_audio_app_[j]); + state_ctrl_->OnStateChanged(simple_app_, + valid_states_for_not_audio_app_[i], + valid_states_for_not_audio_app_[j]); EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(_)).Times(0); EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); @@ -635,7 +1105,7 @@ TEST_F(StateControllerTest, OnStateChangedWithDifferentStates) { } } -TEST_F(StateControllerTest, OnStateChangedToNone) { +TEST_F(StateControllerImplTest, OnStateChangedToNone) { using namespace am; using namespace mobile_apis; @@ -647,249 +1117,168 @@ TEST_F(StateControllerTest, OnStateChangedToNone) { SystemContext::SYSCTXT_MAIN); EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0); - state_ctrl_.OnStateChanged(simple_app_, none_state, not_none_state); + state_ctrl_->OnStateChanged(simple_app_, none_state, not_none_state); EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(1); - state_ctrl_.OnStateChanged(simple_app_, not_none_state, none_state); + state_ctrl_->OnStateChanged(simple_app_, not_none_state, none_state); } -TEST_F(StateControllerTest, MoveSimpleAppToValidStates) { - using am::HmiState; - using am::HmiStatePtr; - using am::UsageStatistics; +TEST_F(StateControllerImplTest, MoveSimpleAppToValidStates) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - HmiStatePtr initial_state = - createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM); + HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::INVALID_ENUM, + SystemContext::INVALID_ENUM); for (std::vector<HmiStatePtr>::iterator it = valid_states_for_not_audio_app_.begin(); - it != valid_states_for_not_audio_app_.end(); ++it) { + it != valid_states_for_not_audio_app_.end(); + ++it) { HmiStatePtr state_to_setup = *it; EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) .WillOnce(Return(initial_state)) .WillOnce(Return(state_to_setup)); EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(simple_app_)); EXPECT_CALL(app_manager_mock_, - OnHMILevelChanged(simple_app_id_, initial_state->hmi_level(), + OnHMILevelChanged(simple_app_id_, + initial_state->hmi_level(), state_to_setup->hmi_level())); EXPECT_CALL(*simple_app_ptr_, SetRegularState(Truly(HmiStatesComparator(state_to_setup)))); - state_ctrl_.SetRegularState<false>(simple_app_, state_to_setup); + state_ctrl_->SetRegularState(simple_app_, state_to_setup, false); initial_state = state_to_setup; } } -TEST_F(StateControllerTest, MoveAudioAppAppToValidStates) { - using am::HmiState; - using am::HmiStatePtr; - using am::UsageStatistics; +TEST_F(StateControllerImplTest, MoveAudioNotResumeAppToValidStates) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr audio_app = media_navi_vc_app_; - NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* audio_app_mock = + media_navi_vc_app_ptr_; - HmiStatePtr initial_state = - createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM); + HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::INVALID_ENUM, + SystemContext::INVALID_ENUM); for (std::vector<HmiStatePtr>::iterator it = valid_states_for_audio_app_.begin(); - it != valid_states_for_audio_app_.end(); ++it) { + it != valid_states_for_audio_app_.end(); + ++it) { HmiStatePtr state_to_setup = *it; EXPECT_CALL(*audio_app_mock, CurrentHmiState()) .WillOnce(Return(initial_state)) .WillOnce(Return(state_to_setup)); EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(audio_app)); - EXPECT_CALL( - app_manager_mock_, - OnHMILevelChanged(audio_app->app_id(), initial_state->hmi_level(), - state_to_setup->hmi_level())); + EXPECT_CALL(app_manager_mock_, + OnHMILevelChanged(audio_app->app_id(), + initial_state->hmi_level(), + state_to_setup->hmi_level())); EXPECT_CALL(*audio_app_mock, SetRegularState(Truly(HmiStatesComparator(state_to_setup)))); - state_ctrl_.SetRegularState<false>(media_navi_vc_app_, state_to_setup); + state_ctrl_->SetRegularState(media_navi_vc_app_, state_to_setup, false); initial_state = state_to_setup; } } -/* -TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) { - using am::HmiState; - using am::HmiStatePtr; - using am::UsageStatistics; - namespace HMILevel = mobile_apis::HMILevel; - namespace AudioStreamingState = mobile_apis::AudioStreamingState; - namespace SystemContext = mobile_apis::SystemContext; - - for (std::vector<HmiStatePtr>::iterator valid_state_it = - valid_states_for_not_audio_app_.begin(); - valid_state_it != valid_states_for_not_audio_app_.end(); - ++valid_state_it) { - for (std::vector<HmiStatePtr>::iterator invalid_state_it = - common_invalid_states_.begin(); - invalid_state_it != common_invalid_states_.end(); ++invalid_state_it) { - HmiStatePtr initial_state = *valid_state_it; - HmiStatePtr invalid_state = *invalid_state_it; - EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) - .WillOnce(Return(initial_state)); - EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); - EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); - state_ctrl_.SetRegularState<false>(simple_app_, invalid_state); - } - } - - NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_; - am::ApplicationSharedPtr audio_app = media_navi_vc_app_; - for (std::vector<HmiStatePtr>::iterator valid_state_it = - valid_states_for_audio_app_.begin(); - valid_state_it != valid_states_for_audio_app_.end(); ++valid_state_it) { - for (std::vector<HmiStatePtr>::iterator invalid_state_it = - invalid_states_for_audio_app.begin(); - invalid_state_it != invalid_states_for_audio_app.end(); - ++invalid_state_it) { - HmiStatePtr initial_state = *valid_state_it; - HmiStatePtr invalid_state = *invalid_state_it; - EXPECT_CALL(*audio_app_mock, CurrentHmiState()) - .WillOnce(Return(initial_state)); - EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); - EXPECT_CALL(*audio_app_mock, SetRegularState(_)).Times(0); - state_ctrl_.SetRegularState<false>(audio_app, invalid_state); - } - } - for (std::vector<HmiStatePtr>::iterator valid_state_it = - valid_states_for_not_audio_app_.begin(); - valid_state_it != valid_states_for_not_audio_app_.end(); - ++valid_state_it) { - for (std::vector<HmiStatePtr>::iterator invalid_state_it = - invalid_states_for_not_audio_app.begin(); - invalid_state_it != invalid_states_for_not_audio_app.end(); - ++invalid_state_it) { - HmiStatePtr initial_state = *valid_state_it; - HmiStatePtr invalid_state = *invalid_state_it; - EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) - .WillOnce(Return(initial_state)); - EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); - EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); - state_ctrl_.SetRegularState<false>(simple_app_, invalid_state); - } - } -} - -TEST_F(StateControllerTest, MoveAppFromInValidStateToValid) { - using am::HmiState; - using am::HmiStatePtr; - using am::UsageStatistics; +TEST_F(StateControllerImplTest, MoveAudioResumeAppToValidStates) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_; am::ApplicationSharedPtr audio_app = media_navi_vc_app_; - HmiStatePtr invalid_state = - createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM); + NiceMock<application_manager_test::MockApplication>* audio_app_mock = + media_navi_vc_app_ptr_; + + HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM, + AudioStreamingState::INVALID_ENUM, + SystemContext::INVALID_ENUM); + // Set all valid states for audio app for (std::vector<HmiStatePtr>::iterator it = valid_states_for_audio_app_.begin(); - it != valid_states_for_audio_app_.end(); ++it) { - HmiStatePtr initial_state = *it; + it != valid_states_for_audio_app_.end(); + ++it) { + HmiStatePtr state_to_setup = *it; + HmiStatePtr state_to_check = state_to_setup; + // First time current state is initial, then it changes to setup state EXPECT_CALL(*audio_app_mock, CurrentHmiState()) - .WillOnce(Return(initial_state)); - EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); - EXPECT_CALL(*audio_app_mock, SetRegularState(_)).Times(0); - state_ctrl_.SetRegularState<false>(audio_app, invalid_state); - } + .WillOnce(Return(initial_state)) + .WillOnce(Return(state_to_setup)); + // Audio resume app when HMI level is LIMITED or FULL gets audible state + if (state_to_setup->hmi_level() == HMILevel::HMI_LIMITED) { + EXPECT_CALL(*audio_app_mock, is_resuming()).WillRepeatedly(Return(true)); + EXPECT_CALL(*message_helper_mock_, + SendOnResumeAudioSourceToHMI(media_navi_vc_app_id_, _)); + state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE); - for (std::vector<HmiStatePtr>::iterator it = - valid_states_for_not_audio_app_.begin(); - it != valid_states_for_not_audio_app_.end(); ++it) { - HmiStatePtr initial_state = *it; - EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) - .WillOnce(Return(initial_state)); - EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); - EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); - state_ctrl_.SetRegularState<false>(simple_app_, invalid_state); + } else { + if (state_to_setup->hmi_level() == HMILevel::HMI_FULL) { + state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE); + } + EXPECT_CALL(*audio_app_mock, is_resuming()).WillRepeatedly(Return(true)); + } + EXPECT_CALL(app_manager_mock_, active_application()) + .WillRepeatedly(Return(am::ApplicationSharedPtr())); + EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(audio_app)) + .Times(AtLeast(0)); + EXPECT_CALL(app_manager_mock_, + OnHMILevelChanged(audio_app->app_id(), + initial_state->hmi_level(), + state_to_setup->hmi_level())) + .Times(AtLeast(0)); + + // Check that we set correct state + EXPECT_CALL(*audio_app_mock, + SetRegularState(Truly(HmiStatesComparator(state_to_check)))); + state_ctrl_->SetRegularState(media_navi_vc_app_, state_to_setup, false); + initial_state = state_to_setup; } } -TEST_F(StateControllerTest, MoveAppFromInValidStateToInvalid) { +TEST_F(StateControllerImplTest, MoveAppFromValidStateToInvalid) { using am::HmiState; using am::HmiStatePtr; - using am::UsageStatistics; - namespace HMILevel = mobile_apis::HMILevel; - namespace AudioStreamingState = mobile_apis::AudioStreamingState; - namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* audio_app_mock = media_navi_vc_app_ptr_; - am::ApplicationSharedPtr audio_app = media_navi_vc_app_; - HmiStatePtr initial_invalid_state = - createHmiState(HMILevel::INVALID_ENUM, AudioStreamingState::INVALID_ENUM, - SystemContext::INVALID_ENUM); - - am::ApplicationConstSharedPtr const_audio_app(audio_app); - - for (std::vector<HmiStatePtr>::iterator it = - invalid_states_for_audio_app.begin(); - it != invalid_states_for_audio_app.end(); ++it) { - HmiStatePtr state_to_setup = *it; - HmiStatePtr default_state = - createHmiState(HMILevel::HMI_LIMITED, AudioStreamingState::AUDIBLE, - SystemContext::SYSCTXT_MAIN); - EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(const_audio_app)) - .WillOnce(Return(HMILevel::HMI_LIMITED)); - EXPECT_CALL(*audio_app_mock, CurrentHmiState()) - .WillOnce(Return(initial_invalid_state)) - .WillOnce(Return(initial_invalid_state)) - .WillOnce(Return(default_state)); - EXPECT_CALL(app_manager_mock_, - OnHMILevelChanged(audio_app->app_id(), - initial_invalid_state->hmi_level(), - default_state->hmi_level())); - EXPECT_CALL(*audio_app_mock, - SetRegularState(Truly(HmiStatesComparator(default_state)))); - state_ctrl_.SetRegularState<false>(audio_app, state_to_setup); + for (std::vector<HmiStatePtr>::iterator invalid_state_it = + common_invalid_states_.begin(); + invalid_state_it != common_invalid_states_.end(); + ++invalid_state_it) { + HmiStatePtr invalid_state = *invalid_state_it; + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, is_resuming()).Times(0); + EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); + EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); + state_ctrl_->SetRegularState(simple_app_, invalid_state, false); } - for (std::vector<HmiStatePtr>::iterator it = - invalid_states_for_not_audio_app.begin(); - it != invalid_states_for_not_audio_app.end(); ++it) { - HmiStatePtr state_to_setup = *it; - HmiStatePtr default_state = createHmiState(HMILevel::HMI_BACKGROUND, - AudioStreamingState::NOT_AUDIBLE, - SystemContext::SYSCTXT_MAIN); - am::ApplicationConstSharedPtr const_simple_app(simple_app_); - EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(const_simple_app)) - .WillOnce(Return(HMILevel::HMI_BACKGROUND)); - EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) - .WillOnce(Return(initial_invalid_state)) - .WillOnce(Return(initial_invalid_state)) - .WillOnce(Return(default_state)); - EXPECT_CALL(app_manager_mock_, - OnHMILevelChanged(simple_app_ptr_->app_id(), - initial_invalid_state->hmi_level(), - default_state->hmi_level())); - EXPECT_CALL(*simple_app_ptr_, - SetRegularState(Truly(HmiStatesComparator(default_state)))); - state_ctrl_.SetRegularState<false>(simple_app_, state_to_setup); + for (std::vector<HmiStatePtr>::iterator invalid_state_it = + common_invalid_states_.begin(); + invalid_state_it != common_invalid_states_.end(); + ++invalid_state_it) { + HmiStatePtr invalid_state = *invalid_state_it; + EXPECT_CALL(*media_navi_vc_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*media_navi_vc_app_ptr_, is_resuming()).Times(0); + EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0); + EXPECT_CALL(*media_navi_vc_app_ptr_, SetRegularState(_)).Times(0); + state_ctrl_->SetRegularState(media_navi_vc_app_, invalid_state, false); } } -*/ -TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) { - using am::HmiState; - using am::HmiStatePtr; + +TEST_F(StateControllerImplTest, + SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_in_full; - NiceMock<ApplicationMock>* app_in_full_mock; + NiceMock<application_manager_test::MockApplication>* app_in_full_mock; am::ApplicationSharedPtr app_moved_to_full; - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; app_in_full = ConfigureApp(&app_in_full_mock, 1761, NOT_MEDIA, NOT_NAVI, NOT_VC); @@ -899,244 +1288,261 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) { InsertApplication(app_in_full); InsertApplication(app_moved_to_full); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullNotAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullNotAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_full, app_in_full_mock, FullNotAudibleState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false); } -TEST_F(StateControllerTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) { - using am::HmiState; - using am::HmiStatePtr; +TEST_F(StateControllerImplTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_in_full = media_navi_vc_app_; - NiceMock<ApplicationMock>* app_in_full_mock = media_navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_in_full_mock = + media_navi_vc_app_ptr_; am::ApplicationSharedPtr app_moved_to_full = simple_app_; - NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = + simple_app_ptr_; InsertApplication(app_in_full); InsertApplication(app_moved_to_full); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullNotAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullNotAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_full, app_in_full_mock, FullAudibleState(), LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToAudioAppAppWhileAnotherTypeAudioAppAppIsInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_in_full = media_app_; - NiceMock<ApplicationMock>* app_in_full_mock = media_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_in_full_mock = + media_app_ptr_; am::ApplicationSharedPtr app_moved_to_full = navi_app_; - NiceMock<ApplicationMock>* app_moved_to_full_mock = navi_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = + navi_app_ptr_; InsertApplication(app_in_full); InsertApplication(app_moved_to_full); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_full, app_in_full_mock, FullAudibleState(), LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_in_full_mock; + NiceMock<application_manager_test::MockApplication>* app_in_full_mock; am::ApplicationSharedPtr app_in_full = ConfigureApp(&app_in_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC); - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; am::ApplicationSharedPtr app_moved_to_full = ConfigureApp(&app_moved_to_full_mock, 1796, MEDIA, NOT_NAVI, NOT_VC); InsertApplication(app_in_full); InsertApplication(app_moved_to_full); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_full, app_in_full_mock, FullAudibleState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_in_limited_mock; + NiceMock<application_manager_test::MockApplication>* app_in_limited_mock; am::ApplicationSharedPtr app_in_limited = ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NAVI, NOT_VC); - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; am::ApplicationSharedPtr app_moved_to_full = ConfigureApp(&app_moved_to_full_mock, 1796, NOT_MEDIA, NAVI, VC); InsertApplication(app_in_limited); InsertApplication(app_moved_to_full); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_limited, app_in_limited_mock, LimitedState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetLimitedToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_in_limited_mock; + NiceMock<application_manager_test::MockApplication>* app_in_limited_mock; am::ApplicationSharedPtr app_in_limited = ConfigureApp(&app_in_limited_mock, 1761, NOT_MEDIA, NOT_NAVI, VC); - NiceMock<ApplicationMock>* app_moved_to_limited_mock; + NiceMock<application_manager_test::MockApplication>* + app_moved_to_limited_mock; am::ApplicationSharedPtr app_moved_to_limited = ConfigureApp(&app_moved_to_limited_mock, 1796, NOT_MEDIA, NOT_NAVI, VC); InsertApplication(app_in_limited); InsertApplication(app_moved_to_limited); - ExpectSuccesfullSetHmiState(app_moved_to_limited, app_moved_to_limited_mock, - BackgroundState(), LimitedState()); + ExpectSuccesfullSetHmiState(app_moved_to_limited, + app_moved_to_limited_mock, + BackgroundState(), + LimitedState()); ExpectAppChangeHmiStateDueToConflictResolving( app_in_limited, app_in_limited_mock, LimitedState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState()); + state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInLimited) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_in_limited = navi_app_; - NiceMock<ApplicationMock>* app_in_limited_mock = navi_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_in_limited_mock = + navi_app_ptr_; am::ApplicationSharedPtr app_moved_to_limited = vc_app_; - NiceMock<ApplicationMock>* app_moved_to_limited_mock = vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* + app_moved_to_limited_mock = vc_app_ptr_; InsertApplication(app_in_limited); InsertApplication(app_moved_to_limited); - ExpectSuccesfullSetHmiState(app_moved_to_limited, app_moved_to_limited_mock, - BackgroundState(), LimitedState()); + ExpectSuccesfullSetHmiState(app_moved_to_limited, + app_moved_to_limited_mock, + BackgroundState(), + LimitedState()); ExpectAppWontChangeHmiStateDueToConflictResolving( app_in_limited, app_in_limited_mock, LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState()); + state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_in_full = navi_app_; - NiceMock<ApplicationMock>* app_in_full_mock = navi_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_in_full_mock = + navi_app_ptr_; am::ApplicationSharedPtr app_moved_to_limited = vc_app_; - NiceMock<ApplicationMock>* app_moved_to_limited_mock = vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* + app_moved_to_limited_mock = vc_app_ptr_; InsertApplication(app_in_full); InsertApplication(app_moved_to_limited); - ExpectSuccesfullSetHmiState(app_moved_to_limited, app_moved_to_limited_mock, - BackgroundState(), LimitedState()); + ExpectSuccesfullSetHmiState(app_moved_to_limited, + app_moved_to_limited_mock, + BackgroundState(), + LimitedState()); ExpectAppWontChangeHmiStateDueToConflictResolving( app_in_full, app_in_full_mock, FullAudibleState()); - state_ctrl_.SetRegularState<false>(app_moved_to_limited, LimitedState()); + state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false); } -TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) { - using am::HmiState; - using am::HmiStatePtr; +TEST_F(StateControllerImplTest, SetFullToSimpleAppWhile2AudioAppsInLimited) { namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_moved_to_full = simple_app_; - NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = + simple_app_ptr_; am::ApplicationSharedPtr limited_app1 = media_app_; - NiceMock<ApplicationMock>* limited_app1_mock = media_app_ptr_; + NiceMock<application_manager_test::MockApplication>* limited_app1_mock = + media_app_ptr_; am::ApplicationSharedPtr limited_app2 = navi_vc_app_; - NiceMock<ApplicationMock>* limited_app2_mock = navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* limited_app2_mock = + navi_vc_app_ptr_; InsertApplication(app_moved_to_full); InsertApplication(limited_app1); InsertApplication(limited_app2); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullNotAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullNotAudibleState()); ExpectAppWontChangeHmiStateDueToConflictResolving( limited_app1, limited_app1_mock, LimitedState()); ExpectAppWontChangeHmiStateDueToConflictResolving( limited_app2, limited_app2_mock, LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToSimpleAppWhile1AudioAppInLimitedAnd1AudioAppInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; am::ApplicationSharedPtr app_moved_to_full = simple_app_; - NiceMock<ApplicationMock>* app_moved_to_full_mock = simple_app_ptr_; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock = + simple_app_ptr_; am::ApplicationSharedPtr limited_app = media_app_; - NiceMock<ApplicationMock>* limited_app_mock = media_app_ptr_; + NiceMock<application_manager_test::MockApplication>* limited_app_mock = + media_app_ptr_; am::ApplicationSharedPtr full_app = navi_vc_app_; - NiceMock<ApplicationMock>* full_app_mock = navi_vc_app_ptr_; + NiceMock<application_manager_test::MockApplication>* full_app_mock = + navi_vc_app_ptr_; InsertApplication(app_moved_to_full); InsertApplication(limited_app); InsertApplication(full_app); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullNotAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullNotAudibleState()); ExpectAppWontChangeHmiStateDueToConflictResolving( limited_app, limited_app_mock, LimitedState()); @@ -1144,25 +1550,24 @@ TEST_F(StateControllerTest, ExpectAppChangeHmiStateDueToConflictResolving( full_app, full_app_mock, FullAudibleState(), LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToSimpleAppWhile1AudioAppInLimitedAnd1SimpleAppInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; am::ApplicationSharedPtr app_moved_to_full = ConfigureApp(&app_moved_to_full_mock, 1761, NOT_MEDIA, NOT_NAVI, NOT_VC); am::ApplicationSharedPtr limited_app = media_app_; - NiceMock<ApplicationMock>* limited_app_mock = media_app_ptr_; + NiceMock<application_manager_test::MockApplication>* limited_app_mock = + media_app_ptr_; - NiceMock<ApplicationMock>* full_app_mock; + NiceMock<application_manager_test::MockApplication>* full_app_mock; am::ApplicationSharedPtr full_app = ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC); @@ -1170,8 +1575,10 @@ TEST_F(StateControllerTest, InsertApplication(limited_app); InsertApplication(full_app); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullNotAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullNotAudibleState()); ExpectAppWontChangeHmiStateDueToConflictResolving( limited_app, limited_app_mock, LimitedState()); @@ -1179,27 +1586,25 @@ TEST_F(StateControllerTest, ExpectAppChangeHmiStateDueToConflictResolving( full_app, full_app_mock, FullNotAudibleState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullNotAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullNotAudibleState(), false); } TEST_F( - StateControllerTest, + StateControllerImplTest, SetFullToAudioAppWhile1AudioAppWithSameTypeInLimitedAnd1SimpleAppInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; am::ApplicationSharedPtr app_moved_to_full = ConfigureApp(&app_moved_to_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC); - NiceMock<ApplicationMock>* limited_app_mock; + NiceMock<application_manager_test::MockApplication>* limited_app_mock; am::ApplicationSharedPtr limited_app = ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC); - NiceMock<ApplicationMock>* full_app_mock; + NiceMock<application_manager_test::MockApplication>* full_app_mock; am::ApplicationSharedPtr full_app = ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NOT_NAVI, NOT_VC); @@ -1207,8 +1612,10 @@ TEST_F( InsertApplication(limited_app); InsertApplication(full_app); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( limited_app, limited_app_mock, LimitedState(), BackgroundState()); @@ -1216,27 +1623,25 @@ TEST_F( ExpectAppChangeHmiStateDueToConflictResolving( full_app, full_app_mock, FullNotAudibleState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false); } TEST_F( - StateControllerTest, + StateControllerImplTest, SetFullToAudioAppWhileAudioAppWithSameTypeInLimitedAndAudioAppWithOtherTypeInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; - NiceMock<ApplicationMock>* app_moved_to_full_mock; + NiceMock<application_manager_test::MockApplication>* app_moved_to_full_mock; am::ApplicationSharedPtr app_moved_to_full = ConfigureApp(&app_moved_to_full_mock, 1761, MEDIA, NOT_NAVI, NOT_VC); - NiceMock<ApplicationMock>* limited_app_mock; + NiceMock<application_manager_test::MockApplication>* limited_app_mock; am::ApplicationSharedPtr limited_app = ConfigureApp(&limited_app_mock, 1762, MEDIA, NOT_NAVI, NOT_VC); - NiceMock<ApplicationMock>* full_app_mock; + NiceMock<application_manager_test::MockApplication>* full_app_mock; am::ApplicationSharedPtr full_app = ConfigureApp(&full_app_mock, 1796, NOT_MEDIA, NAVI, NOT_VC); @@ -1244,8 +1649,10 @@ TEST_F( InsertApplication(limited_app); InsertApplication(full_app); - ExpectSuccesfullSetHmiState(app_moved_to_full, app_moved_to_full_mock, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(app_moved_to_full, + app_moved_to_full_mock, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( limited_app, limited_app_mock, LimitedState(), BackgroundState()); @@ -1253,13 +1660,11 @@ TEST_F( ExpectAppChangeHmiStateDueToConflictResolving( full_app, full_app_mock, FullAudibleState(), LimitedState()); - state_ctrl_.SetRegularState<false>(app_moved_to_full, FullAudibleState()); + state_ctrl_->SetRegularState(app_moved_to_full, FullAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToAudioAppWhile3AudioAppsWithSameTypeInLimited) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; @@ -1268,21 +1673,21 @@ TEST_F(StateControllerTest, InsertApplication(media_app_); InsertApplication(navi_app_); InsertApplication(vc_app_); - ExpectSuccesfullSetHmiState(media_navi_vc_app_, media_navi_vc_app_ptr_, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(media_navi_vc_app_, + media_navi_vc_app_ptr_, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( media_app_, media_app_ptr_, LimitedState(), BackgroundState()); ExpectAppChangeHmiStateDueToConflictResolving( navi_app_, navi_app_ptr_, LimitedState(), BackgroundState()); ExpectAppChangeHmiStateDueToConflictResolving( vc_app_, vc_app_ptr_, LimitedState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(media_navi_vc_app_, FullAudibleState()); + state_ctrl_->SetRegularState(media_navi_vc_app_, FullAudibleState(), false); } -TEST_F(StateControllerTest, +TEST_F(StateControllerImplTest, SetFullToAudioAppWhile2AudioAppsWithSameTypeInLimitedAndOneInFull) { - using am::HmiState; - using am::HmiStatePtr; namespace HMILevel = mobile_apis::HMILevel; namespace AudioStreamingState = mobile_apis::AudioStreamingState; namespace SystemContext = mobile_apis::SystemContext; @@ -1291,18 +1696,21 @@ TEST_F(StateControllerTest, InsertApplication(media_app_); InsertApplication(navi_app_); InsertApplication(vc_app_); - ExpectSuccesfullSetHmiState(media_navi_vc_app_, media_navi_vc_app_ptr_, - BackgroundState(), FullAudibleState()); + ExpectSuccesfullSetHmiState(media_navi_vc_app_, + media_navi_vc_app_ptr_, + BackgroundState(), + FullAudibleState()); ExpectAppChangeHmiStateDueToConflictResolving( media_app_, media_app_ptr_, LimitedState(), BackgroundState()); ExpectAppChangeHmiStateDueToConflictResolving( navi_app_, navi_app_ptr_, LimitedState(), BackgroundState()); ExpectAppChangeHmiStateDueToConflictResolving( vc_app_, vc_app_ptr_, FullAudibleState(), BackgroundState()); - state_ctrl_.SetRegularState<false>(media_navi_vc_app_, FullAudibleState()); + state_ctrl_->SetRegularState(media_navi_vc_app_, FullAudibleState(), false); } -TEST_F(StateControllerTest, ActivateAppSuccessReceivedFromHMI) { +// TODO {AKozoriz} Changed logic in state_controller +TEST_F(StateControllerImplTest, DISABLED_ActivateAppSuccessReceivedFromHMI) { using namespace hmi_apis; using namespace mobile_apis; @@ -1318,45 +1726,48 @@ TEST_F(StateControllerTest, ActivateAppSuccessReceivedFromHMI) { StateLevelPair(LimitedState(), Common_HMILevel::LIMITED)); hmi_states.push_back( StateLevelPair(BackgroundState(), Common_HMILevel::BACKGROUND)); - hmi_states.push_back(StateLevelPair( - createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE, - SystemContext::SYSCTXT_MAIN), - Common_HMILevel::NONE)); + hmi_states.push_back( + StateLevelPair(createHmiState(HMILevel::HMI_NONE, + AudioStreamingState::NOT_AUDIBLE, + SystemContext::SYSCTXT_MAIN), + Common_HMILevel::NONE)); std::vector<StateLevelPair> initial_hmi_states = hmi_states; std::vector<StateLevelPair>::iterator it = hmi_states.begin(); std::vector<StateLevelPair>::iterator it2 = initial_hmi_states.begin(); + smart_objects::SmartObjectSPtr bc_activate_app_request = + new smart_objects::SmartObject(); + (*bc_activate_app_request)[am::strings::params][am::strings::correlation_id] = + corr_id; + for (; it != hmi_states.end(); ++it) { - for (; it2 != initial_hmi_states.end(); ++it2) { - am::HmiStatePtr hmi_state = it->first; - am::HmiStatePtr initial_hmi_state = it->first; - Common_HMILevel::eType hmi_level = it->second; + am::HmiStatePtr hmi_state = it->first; + am::HmiStatePtr initial_hmi_state = it->first; + Common_HMILevel::eType hmi_level = it->second; - EXPECT_CALL(*message_helper_mock_, - SendActivateAppToHMI(media_app_->app_id(), hmi_level, _)) - .WillOnce(Return(corr_id)); - EXPECT_CALL(app_manager_mock_, application_id(corr_id)) - .WillOnce(Return(hmi_app_id)); - EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id)) - .WillOnce(Return(media_app_)); - ExpectSuccesfullSetHmiState(media_app_, media_app_ptr_, initial_hmi_state, - hmi_state); - state_ctrl_.SetRegularState<true>(media_app_, hmi_state); - smart_objects::SmartObject message; - message[am::strings::params][am::hmi_response::code] = - Common_Result::SUCCESS; - message[am::strings::params][am::strings::correlation_id] = corr_id; - am::event_engine::Event event( - hmi_apis::FunctionID::BasicCommunication_ActivateApp); - event.set_smart_object(message); - state_ctrl_.on_event(event); - } + SetBCActivateAppRequestToHMI(hmi_level, corr_id); + ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request)) + .WillByDefault(Return(true)); + + EXPECT_CALL(app_manager_mock_, application_id(corr_id)) + .WillOnce(Return(hmi_app_id)); + EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id)) + .WillOnce(Return(media_app_)); + ExpectSuccesfullSetHmiState( + media_app_, media_app_ptr_, initial_hmi_state, hmi_state); + state_ctrl_->SetRegularState(media_app_, hmi_state, true); + smart_objects::SmartObject message; + message[am::strings::params][am::hmi_response::code] = + Common_Result::SUCCESS; + message[am::strings::params][am::strings::correlation_id] = corr_id; + am::event_engine::Event event( + hmi_apis::FunctionID::BasicCommunication_ActivateApp); + event.set_smart_object(message); + state_ctrl_->on_event(event); } } -/* -TEST_F(StateControllerTest, ActivateAppErrorReceivedFromHMI) { + +std::vector<hmi_apis::Common_Result::eType> hmi_result() { using namespace hmi_apis; - const uint32_t corr_id = 314; - const uint32_t hmi_app_id = 2718; std::vector<Common_Result::eType> hmi_results; hmi_results.push_back(Common_Result::ABORTED); hmi_results.push_back(Common_Result::APPLICATION_NOT_REGISTERED); @@ -1383,45 +1794,45 @@ TEST_F(StateControllerTest, ActivateAppErrorReceivedFromHMI) { hmi_results.push_back(Common_Result::USER_DISALLOWED); hmi_results.push_back(Common_Result::WARNINGS); hmi_results.push_back(Common_Result::WRONG_LANGUAGE); + return hmi_results; +} + +TEST_F(StateControllerImplTest, SendEventBCActivateApp_HMIReceivesError) { + using namespace hmi_apis; + const uint32_t corr_id = 314; + const uint32_t hmi_app_id = 2718; + std::vector<Common_Result::eType> hmi_results = hmi_result(); std::vector<Common_Result::eType>::iterator it = hmi_results.begin(); for (; it != hmi_results.end(); ++it) { - EXPECT_CALL( - *message_helper_mock_, - SendActivateAppToHMI(simple_app_->app_id(), Common_HMILevel::FULL, _)) - .WillOnce(Return(corr_id)); EXPECT_CALL(app_manager_mock_, application_id(corr_id)) .WillOnce(Return(hmi_app_id)); EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id)) .WillOnce(Return(simple_app_)); - EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) - .WillOnce(Return(BackgroundState())); - EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) - .WillOnce(Return(BackgroundState())) - .WillOnce(Return(BackgroundState())); - EXPECT_CALL(*simple_app_ptr_, - SetRegularState(Truly(HmiStatesComparator(BackgroundState())))); + + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); + EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(simple_app_)) .Times(0); EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(simple_app_->app_id(), _, _)).Times(0); - state_ctrl_.SetRegularState<true>(simple_app_, FullNotAudibleState()); + smart_objects::SmartObject message; message[am::strings::params][am::hmi_response::code] = *it; message[am::strings::params][am::strings::correlation_id] = corr_id; am::event_engine::Event event(FunctionID::BasicCommunication_ActivateApp); event.set_smart_object(message); - state_ctrl_.on_event(event); + state_ctrl_->on_event(event); } } -*/ -TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) { + +TEST_F(StateControllerImplTest, ActivateAppInvalidCorrelationId) { using namespace hmi_apis; const uint32_t corr_id = 314; const uint32_t hmi_app_id = 2718; - EXPECT_CALL(*message_helper_mock_, - SendActivateAppToHMI(simple_app_->app_id(), Common_HMILevel::FULL, - _)).WillOnce(Return(hmi_app_id)); + EXPECT_CALL(app_manager_mock_, application_id(corr_id)) .WillOnce(Return(hmi_app_id)); EXPECT_CALL(app_manager_mock_, application_by_hmi_app(hmi_app_id)) @@ -1431,53 +1842,642 @@ TEST_F(StateControllerTest, ActivateAppInvalidCorrelationId) { .Times(0); EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(simple_app_->app_id(), _, _)) .Times(0); - state_ctrl_.SetRegularState<true>(simple_app_, FullNotAudibleState()); + SetBCActivateAppRequestToHMI(Common_HMILevel::FULL, corr_id); + state_ctrl_->SetRegularState(simple_app_, FullNotAudibleState(), true); smart_objects::SmartObject message; message[am::strings::params][am::hmi_response::code] = Common_Result::SUCCESS; message[am::strings::params][am::strings::correlation_id] = corr_id; am::event_engine::Event event(FunctionID::BasicCommunication_ActivateApp); event.set_smart_object(message); - state_ctrl_.on_event(event); + state_ctrl_->on_event(event); } -/* -TEST_F(StateControllerTest, ApplyTempStatesForSimpleApp) { + +TEST_F(StateControllerImplTest, ApplyTempStatesForSimpleApp) { InsertApplication(simple_app_); CheckStateApplyingForApplication(*simple_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForMediaApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForMediaApp) { InsertApplication(media_app_); CheckStateApplyingForApplication(*media_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForNaviApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) { InsertApplication(navi_app_); CheckStateApplyingForApplication(*navi_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForVCApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForVCApp) { InsertApplication(vc_app_); CheckStateApplyingForApplication(*vc_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) { InsertApplication(media_navi_app_); CheckStateApplyingForApplication(*media_navi_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForMediaVCApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForMediaVCApp) { InsertApplication(media_vc_app_); CheckStateApplyingForApplication(*media_vc_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForNaviVCApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForNaviVCApp) { InsertApplication(navi_vc_app_); CheckStateApplyingForApplication(*navi_vc_app_ptr_, valid_state_ids_); } -TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviVCApp) { +TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviVCApp) { InsertApplication(media_navi_vc_app_); CheckStateApplyingForApplication(*media_navi_vc_app_ptr_, valid_state_ids_); } -*/ + +TEST_F(StateControllerImplTest, SetStatePhoneCallForNonMediaApplication) { + am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>( + simple_app_id_, app_manager_mock_); + TestSetState(simple_app_, + state_phone_call, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaApplication) { + am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>( + media_app_id_, app_manager_mock_); + TestSetState(media_app_, + state_phone_call, + APP_TYPE_MEDIA, + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaNaviApplication) { + am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>( + media_navi_app_id_, app_manager_mock_); + TestSetState(media_navi_app_, + state_phone_call, + APP_TYPE_NAVI, + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetVRStateForNonMediaApplication) { + am::HmiStatePtr state_vr = + utils::MakeShared<am::VRHmiState>(simple_app_id_, app_manager_mock_); + TestSetState(simple_app_, + state_vr, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetVRStateForMediaApplication) { + am::HmiStatePtr state_vr = + utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_); + TestSetState(media_app_, + state_vr, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetVRStateForMediaNaviVoiceApplication) { + am::HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>( + media_navi_vc_app_id_, app_manager_mock_); + TestSetState(media_navi_vc_app_, + state_vr, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForNonMediaApplicationAttenuatedNotSupported) { + am::HmiStatePtr state_tts = + utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + TestSetState(simple_app_, + state_tts, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForNonMediaApplicationAttenuatedSupported) { + am::HmiStatePtr state_tts = + utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + TestSetState(simple_app_, + state_tts, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForMediaApplicationAttenuatedNotSupported) { + am::HmiStatePtr state_tts = + utils::MakeShared<am::TTSHmiState>(media_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + TestSetState(media_app_, + state_tts, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForMediaApplicationAttenuatedSupported) { + am::HmiStatePtr state_tts = + utils::MakeShared<am::TTSHmiState>(media_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + TestSetState(media_app_, + state_tts, + APP_TYPE_ATTENUATED, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForMediaNaviVCApplicationAttenuatedNotSupported) { + am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>( + media_navi_vc_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + TestSetState(media_navi_vc_app_, + state_tts, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetTTSStateForMediaNaviVCApplicationAttenuatedSupported) { + am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>( + media_navi_vc_app_id_, app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + TestSetState(media_navi_vc_app_, + state_tts, + APP_TYPE_ATTENUATED, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(simple_app_id_, + app_manager_mock_); + TestSetState(simple_app_, + state_navi_streming, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PrepareNaviStreamingHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_, + app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + TestSetState(media_app_, + state_navi_streming, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareNaviStreamingHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetNaviStreamingStateMediaApplicationAttenuatedSupported) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_, + app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + TestSetState(media_app_, + state_navi_streming, + APP_TYPE_ATTENUATED, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetNaviStreamingStateVCApplicationAttenuatedNotSupported) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_, + app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + TestSetState(vc_app_, + state_navi_streming, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareNaviStreamingHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetNaviStreamingStateVCApplicationAttenuatedSupported) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_, + app_manager_mock_); + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + TestSetState(vc_app_, + state_navi_streming, + APP_TYPE_ATTENUATED, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(navi_app_id_, + app_manager_mock_); + TestSetState(navi_app_, + state_navi_streming, + APP_TYPE_NAVI, + &StateControllerImplTest::PrepareNaviStreamingHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) { + am::HmiStatePtr state_navi_streming = + utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_id_, + app_manager_mock_); + TestSetState(media_navi_app_, + state_navi_streming, + APP_TYPE_NAVI, + &StateControllerImplTest::PrepareNaviStreamingHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetSafetyModeStateForNonMediaApplication) { + am::HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>( + simple_app_id_, app_manager_mock_); + TestSetState(simple_app_, + state_safety_mode, + APP_TYPE_NON_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetSafetyModeStateForMediaApplication) { + am::HmiStatePtr state_safety_mode = + utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_); + TestSetState(media_app_, + state_safety_mode, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + SetSafetyModeStateForMediaNaviVoiceApplication) { + am::HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>( + media_navi_vc_app_id_, app_manager_mock_); + TestSetState(media_navi_vc_app_, + state_safety_mode, + APP_TYPE_MEDIA, + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixVRWithPhoneCall) { + TestMixState<am::PhoneCallHmiState, am::VRHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixTTSWithPhoneCallAttenuatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::PhoneCallHmiState, am::TTSHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixTTSWithPhoneCallAttenuatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::PhoneCallHmiState, am::TTSHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, + MixNaviStreamingWithPhoneCallAttenuatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, + MixNaviStreamingWithPhoneCallAttenuatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixSafetyModeWithPhoneCall) { + TestMixState<am::PhoneCallHmiState, am::SafetyModeHmiState>( + &StateControllerImplTest::PreparePhoneCallHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixTTSWithVRAttenuatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::VRHmiState, am::TTSHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixTTSWithVRAttenuatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::VRHmiState, am::TTSHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::VRHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::VRHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixSafetyModeStreamingWithVR) { + TestMixState<am::VRHmiState, am::SafetyModeHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + MixNaviStreamingWithTTSAttenueatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixNaviStreamingWithTTSAttenueatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareNaviStreamTTSStateResult); +} + +TEST_F(StateControllerImplTest, MixSafetyModeWithTTSAttenueatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::TTSHmiState, am::SafetyModeHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, MixSafetyModeWithTTSAttenueatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::TTSHmiState, am::SafetyModeHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + MixSafetyModeWithNaviStreamingAttenueatedNotSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(false)); + + TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, + MixSafetyModeWithNaviStreamingAttenueatedSupported) { + EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) + .WillRepeatedly(Return(true)); + + TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>( + &StateControllerImplTest::PrepareVRTTSHMIStateResults); +} + +TEST_F(StateControllerImplTest, SetRegularStateWithNewHmiLvl) { + using namespace mobile_apis; + + HMILevel::eType set_lvl = HMILevel::HMI_NONE; + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) + .WillOnce(Return(BackgroundState())); + + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) + .WillOnce(Return(BackgroundState())) + .WillOnce(Return(BackgroundState())); + + state_ctrl_->SetRegularState(simple_app_, set_lvl); + + set_lvl = HMILevel::HMI_LIMITED; + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) + .WillOnce(Return(BackgroundState())); + + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) + .WillOnce(Return(BackgroundState())) + .WillOnce(Return(BackgroundState())); + state_ctrl_->SetRegularState(simple_app_, set_lvl); + + set_lvl = HMILevel::HMI_FULL; + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) + .WillOnce(Return(BackgroundState())); + + const uint32_t corr_id = 314; + SetBCActivateAppRequestToHMI( + static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl), corr_id); + + state_ctrl_->SetRegularState(simple_app_, set_lvl); + + set_lvl = HMILevel::HMI_BACKGROUND; + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) + .WillOnce(Return(BackgroundState())); + + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) + .WillOnce(Return(BackgroundState())) + .WillOnce(Return(BackgroundState())); + + state_ctrl_->SetRegularState(simple_app_, set_lvl); +} + +TEST_F(StateControllerImplTest, SetRegularStateWithAudioStateAudible) { + using namespace mobile_apis; + + HmiStatePtr check_state = createHmiState(HMILevel::HMI_BACKGROUND, + AudioStreamingState::AUDIBLE, + SystemContext::SYSCTXT_MAIN); + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()) + .WillRepeatedly(Return(BackgroundState())); + + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) + .WillOnce(Return(check_state)) + .WillOnce(Return(check_state)); + EXPECT_CALL(*simple_app_ptr_, + SetRegularState(Truly(HmiStatesComparator(check_state)))); + + state_ctrl_->SetRegularState(simple_app_, AudioStreamingState::AUDIBLE); +} + +TEST_F(StateControllerImplTest, + SetRegularStateToMediaAndNonMediaApps_VRStarted_SetPostponedState) { + using namespace mobile_apis; + + // Precondition + am::event_engine::Event event(hmi_apis::FunctionID::VR_Started); + state_ctrl_->on_event(event); + + HmiStatePtr check_state = FullNotAudibleState(); + + // Non-media app can't have LIMITED-AUDIO state + EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); + EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(_)) + .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_NONE)); + EXPECT_CALL(app_manager_mock_, active_application()) + .WillRepeatedly(Return(am::ApplicationSharedPtr())); + EXPECT_CALL(*simple_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(simple_app_, check_state, false); + + check_state = LimitedState(); + EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*media_app_ptr_, SetRegularState(_)).Times(0); + EXPECT_CALL(*media_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(media_app_, check_state, false); +} + +TEST_F(StateControllerImplTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) { + using namespace mobile_apis; + + // Precondition + am::event_engine::Event prev_event(hmi_apis::FunctionID::VR_Started); + state_ctrl_->on_event(prev_event); + + am::event_engine::Event next_event(hmi_apis::FunctionID::VR_Stopped); + state_ctrl_->on_event(next_event); + + // Set state of non-media app after vr has stopped + HmiStatePtr check_state = FullNotAudibleState(); + + // Non-media app can't have LIMITED-AUDIO state + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()) + .WillOnce(Return(check_state)) + .WillOnce(Return(check_state)); + + EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false)); + + EXPECT_CALL(*message_helper_mock_, + SendOnResumeAudioSourceToHMI(simple_app_id_, _)).Times(0); + EXPECT_CALL(*simple_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))) + .Times(0); + EXPECT_CALL(*simple_app_ptr_, + SetRegularState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(simple_app_, check_state, false); + + // Set state of media app after vr has stopped + check_state = LimitedState(); + + EXPECT_CALL(*media_app_ptr_, CurrentHmiState()) + .WillOnce(Return(check_state)) + .WillOnce(Return(check_state)); + + EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + + EXPECT_CALL(*message_helper_mock_, + SendOnResumeAudioSourceToHMI(media_app_id_, _)); + EXPECT_CALL(*media_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))) + .Times(0); + EXPECT_CALL(*media_app_ptr_, + SetRegularState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(media_app_, check_state, false); +} + +TEST_F(StateControllerImplTest, + SetRegStateForMediaAndNonMediaApps_OnEmergencyEvent_SetPostponedState) { + using namespace hmi_apis; + using namespace smart_objects; + using namespace am::event_engine; + + // Precondition + Event event(FunctionID::BasicCommunication_OnEventChanged); + SmartObject message; + message[am::strings::msg_params][am::hmi_notification::is_active] = true; + message[am::strings::msg_params][am::hmi_notification::event_name] = + Common_EventTypes::EMERGENCY_EVENT; + + event.set_smart_object(message); + state_ctrl_->on_event(event); + + // Non-media app can't have LIMITED-AUDIO state + HmiStatePtr check_state = FullNotAudibleState(); + EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + + EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0); + EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(_)) + .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_NONE)); + EXPECT_CALL(app_manager_mock_, active_application()) + .WillRepeatedly(Return(am::ApplicationSharedPtr())); + EXPECT_CALL(*simple_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(simple_app_, check_state, false); + + // Set media app + check_state = LimitedState(); + EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + + EXPECT_CALL(*media_app_ptr_, RegularHmiState()).Times(0); + EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0); + EXPECT_CALL(*media_app_ptr_, SetRegularState(_)).Times(0); + + EXPECT_CALL(*media_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(media_app_, check_state, false); +} + +TEST_F(StateControllerImplTest, + SetStateForMediaApp_BCOnPhoneCall_SetPostponedState) { + using namespace hmi_apis; + using namespace smart_objects; + using namespace am::event_engine; + + // Precondition + Event event(FunctionID::BasicCommunication_OnEventChanged); + SmartObject message; + message[am::strings::msg_params][am::hmi_notification::is_active] = true; + message[am::strings::msg_params][am::hmi_notification::event_name] = + hmi_apis::Common_EventTypes::PHONE_CALL; + + event.set_smart_object(message); + state_ctrl_->on_event(event); + + am::HmiStatePtr check_state = FullAudibleState(); + + EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true)); + + EXPECT_CALL(*media_app_ptr_, is_media_application()) + .WillRepeatedly(Return(true)); + + EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_)) + .WillRepeatedly(Return(false)); + + EXPECT_CALL(app_manager_mock_, active_application()) + .WillRepeatedly(Return(am::ApplicationSharedPtr())); + + EXPECT_CALL(*media_app_ptr_, + SetPostponedState(Truly(HmiStatesComparator(check_state)))); + state_ctrl_->SetRegularState(media_app_, check_state, false); +} + } // namespace state_controller_test +} // namespace components +} // namespace test |