summaryrefslogtreecommitdiff
path: root/src/components/application_manager/test/state_controller/state_controller_test.cc
diff options
context:
space:
mode:
authorJackLivio <jack@livio.io>2018-08-22 14:33:20 -0400
committerJackLivio <jack@livio.io>2018-08-22 14:33:20 -0400
commit2b9dbd15a3170b89a2ba9752faf56d6a7ee0910c (patch)
treec4b5792cb861816ca9c12d42246f4ce333e39285 /src/components/application_manager/test/state_controller/state_controller_test.cc
parent203aedc01958fe8e0825f70599f8cda0f621ae5c (diff)
parent6a436addb2811c3fbc6ff155a8a142aa14c8ec45 (diff)
downloadsdl_core-2b9dbd15a3170b89a2ba9752faf56d6a7ee0910c.tar.gz
Merge remote-tracking branch 'origin/develop' into feature/PLAY_PAUSE_implementation
# Conflicts: # src/appMain/hmi_capabilities.json # src/components/application_manager/src/commands/mobile/subscribe_button_request.cc # src/components/application_manager/test/hmi_capabilities.json # src/components/interfaces/MOBILE_API.xml # src/components/interfaces/QT_HMI_API.xml # src/components/utils/test/test_generator/MOBILE_API.xml
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.cc985
1 files changed, 844 insertions, 141 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 f19a0896d1..3731848d89 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
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2015, Ford Motor Company
+ * Copyright (c) 2017, Ford Motor Company
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -39,21 +39,22 @@
#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 "policy/usage_statistics/mock_statistics_manager.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"
+#include "application_manager/mock_rpc_service.h"
namespace am = application_manager;
using am::HmiState;
@@ -63,39 +64,48 @@ using ::testing::_;
using ::testing::Return;
using ::testing::ReturnRef;
using ::testing::ReturnPointee;
+using ::testing::SaveArg;
using ::testing::Mock;
using ::testing::NiceMock;
using ::testing::InSequence;
using ::testing::Truly;
using ::testing::AtLeast;
-static application_manager::MockMessageHelper* message_helper_mock_;
-
namespace test {
namespace components {
namespace state_controller_test {
+namespace constants {
+const uint32_t kCorrID = 314u;
+const uint32_t kHMIAppID = 2718u;
+} // namespace constants
+
struct HmiStatesComparator {
mobile_apis::HMILevel::eType hmi_level_;
mobile_apis::AudioStreamingState::eType audio_streaming_state_;
+ mobile_apis::VideoStreamingState::eType video_streaming_state_;
mobile_apis::SystemContext::eType system_context_;
HmiStatesComparator(
mobile_apis::HMILevel::eType hmi_level,
mobile_apis::AudioStreamingState::eType audio_streaming_state,
+ mobile_apis::VideoStreamingState::eType video_streaming_state,
mobile_apis::SystemContext::eType system_context)
: hmi_level_(hmi_level)
, audio_streaming_state_(audio_streaming_state)
+ , video_streaming_state_(video_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())
+ , video_streaming_state_(state_ptr->video_streaming_state())
, system_context_(state_ptr->system_context()) {}
bool operator()(am::HmiStatePtr state_ptr) const {
return state_ptr->hmi_level() == hmi_level_ &&
state_ptr->audio_streaming_state() == audio_streaming_state_ &&
+ state_ptr->video_streaming_state() == video_streaming_state_ &&
state_ptr->system_context() == system_context_;
}
};
@@ -129,11 +139,21 @@ class StateControllerImplTest : public ::testing::Test {
StateControllerImplTest()
: ::testing::Test()
, usage_stat("0",
- utils::SharedPtr<usage_statistics::StatisticsManager>(
+ std::shared_ptr<usage_statistics::StatisticsManager>(
+ new usage_statistics_test::MockStatisticsManager))
+ , applications_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+ , applications_(application_set_, applications_lock_ptr_)
+ , message_helper_mock_(
+ *application_manager::MockMessageHelper::message_helper_mock()) {
+ Mock::VerifyAndClearExpectations(&message_helper_mock_);
+ }
+
+ ~StateControllerImplTest() {
+ Mock::VerifyAndClearExpectations(&message_helper_mock_);
+ }
- new state_controller_test::MockStatisticsManager))
- , applications_(application_set_, applications_lock_) {}
NiceMock<application_manager_test::MockApplicationManager> app_manager_mock_;
+ NiceMock<application_manager_test::MockRPCService> mock_rpc_service_;
NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_;
NiceMock<connection_handler_test::MockConnectionHandler>
mock_connection_handler_;
@@ -143,9 +163,9 @@ class StateControllerImplTest : public ::testing::Test {
NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
am::ApplicationSet application_set_;
- mutable sync_primitives::Lock applications_lock_;
+ mutable std::shared_ptr<sync_primitives::Lock> applications_lock_ptr_;
DataAccessor<am::ApplicationSet> applications_;
- utils::SharedPtr<am::StateControllerImpl> state_ctrl_;
+ std::shared_ptr<am::StateControllerImpl> state_ctrl_;
am::ApplicationSharedPtr simple_app_;
NiceMock<application_manager_test::MockApplication>* simple_app_ptr_;
@@ -191,24 +211,49 @@ class StateControllerImplTest : public ::testing::Test {
mock_connection_handler__settings;
transport_manager_test::MockTransportManager mock_transport_manager;
connection_handler::ConnectionHandlerImpl* conn_handler;
+ application_manager::MockMessageHelper& message_helper_mock_;
am::HmiStatePtr createHmiState(
mobile_apis::HMILevel::eType hmi_level,
- mobile_apis::AudioStreamingState::eType aidio_ss,
+ mobile_apis::AudioStreamingState::eType audio_ss,
+ mobile_apis::VideoStreamingState::eType video_ss,
mobile_apis::SystemContext::eType system_context) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
am::HmiStatePtr state =
- utils::MakeShared<am::HmiState>(simple_app_id_, app_manager_mock_);
+ std::make_shared<am::HmiState>(simple_app_, app_manager_mock_);
state->set_hmi_level(hmi_level);
- state->set_audio_streaming_state(aidio_ss);
+ state->set_audio_streaming_state(audio_ss);
+ state->set_video_streaming_state(video_ss);
state->set_system_context(system_context);
return state;
}
/**
+ * @brief Template created for the future if different hmi
+ * states are needed.
+ */
+ template <class HmiStateType>
+ am::HmiStatePtr CreateHmiStateByHmiStateType(
+ const mobile_apis::HMILevel::eType hmi_level,
+ const mobile_apis::AudioStreamingState::eType audio_ss,
+ const mobile_apis::VideoStreamingState::eType video_ss,
+ const mobile_apis::SystemContext::eType system_context,
+ const am::ApplicationSharedPtr app) {
+ am::HmiStatePtr new_state =
+ std::make_shared<HmiStateType>(app, app_manager_mock_);
+
+ new_state->set_hmi_level(hmi_level);
+ new_state->set_audio_streaming_state(audio_ss);
+ new_state->set_video_streaming_state(video_ss);
+ new_state->set_system_context(system_context);
+
+ return new_state;
+ }
+
+ /**
* @brief Prepare list of resultant HMI states for testing HMIState
* @param result_hmi state will contain resultant HMI states.
*/
@@ -216,27 +261,38 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
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,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_NONE,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
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,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MENU));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_NONE,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
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));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_NONE,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_ALERT));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_BACKGROUND,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
}
/**
@@ -248,20 +304,29 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
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));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_LIMITED,
+ AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_LIMITED,
+ AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_FULL,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
+ result_hmi_state.push_back(
+ createHmiState(HMILevel::HMI_FULL,
+ AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN));
}
/**
@@ -273,6 +338,7 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
switch (app_t) {
@@ -281,6 +347,7 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -289,18 +356,22 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -309,18 +380,22 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -337,6 +412,7 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
switch (app_t) {
case APP_TYPE_NON_MEDIA: {
@@ -344,6 +420,7 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -353,18 +430,22 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -385,6 +466,7 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
switch (app_t) {
case APP_TYPE_NON_MEDIA: {
@@ -392,6 +474,7 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -400,18 +483,22 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -433,6 +520,7 @@ class StateControllerImplTest : public ::testing::Test {
std::vector<am::HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
switch (app_t) {
case APP_TYPE_NON_MEDIA: {
@@ -440,6 +528,7 @@ class StateControllerImplTest : public ::testing::Test {
result_hmi_state.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
break;
}
@@ -455,7 +544,7 @@ class StateControllerImplTest : public ::testing::Test {
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
+ // 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(),
@@ -558,10 +647,9 @@ class StateControllerImplTest : public ::testing::Test {
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_first = std::make_shared<T>(app, app_manager_mock_);
am::HmiStatePtr state_second =
- utils::MakeShared<Q>(app_id, app_manager_mock_);
+ std::make_shared<Q>(app, app_manager_mock_);
TestSetSeveralState(
app, state_first, state_second, app_type, call_back_result);
TestSetSeveralState(
@@ -598,148 +686,180 @@ class StateControllerImplTest : public ::testing::Test {
void FillStatesLists() {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
// Valid states for not audio app
- message_helper_mock_ =
- application_manager::MockMessageHelper::message_helper_mock();
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_VRSESSION));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MENU));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_HMI_OBSCURED));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_ALERT));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_not_audio_app_.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
// Valid states audio app
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_VRSESSION));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MENU));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_HMI_OBSCURED));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_ALERT));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
valid_states_for_audio_app_.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
// Common Invalid States
common_invalid_states_.push_back(
createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
common_invalid_states_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
common_invalid_states_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::INVALID_ENUM));
common_invalid_states_.push_back(
createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
common_invalid_states_.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::INVALID_ENUM));
common_invalid_states_.push_back(
createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::INVALID_ENUM));
// Invalid States for audio apps
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_audio_app.push_back(
createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
// Invalid States for not audio apps
invalid_states_for_not_audio_app.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_not_audio_app.push_back(
createHmiState(HMILevel::HMI_LIMITED,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_not_audio_app.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::ATTENUATED,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
invalid_states_for_not_audio_app.push_back(
createHmiState(HMILevel::HMI_FULL,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN));
// Valid state ids
@@ -834,7 +954,7 @@ class StateControllerImplTest : public ::testing::Test {
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_);
+ state_ctrl_ = std::make_shared<am::StateControllerImpl>(app_manager_mock_);
ON_CALL(app_manager_mock_, applications())
.WillByDefault(Return(applications_));
@@ -864,14 +984,15 @@ class StateControllerImplTest : public ::testing::Test {
ON_CALL(app_manager_mock_, GetPolicyHandler())
.WillByDefault(ReturnRef(policy_interface_));
smart_objects::SmartObjectSPtr bc_activate_app_request =
- new smart_objects::SmartObject();
+ std::make_shared<smart_objects::SmartObject>();
(*bc_activate_app_request)[am::strings::params]
[am::strings::correlation_id] = corr_id;
- ON_CALL(*message_helper_mock_,
+ ON_CALL(message_helper_mock_,
GetBCActivateAppRequestToHMI(_, _, _, hmi_lvl, _, _))
.WillByDefault(Return(bc_activate_app_request));
-
- ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request))
+ ON_CALL(app_manager_mock_, GetRPCService())
+ .WillByDefault(ReturnRef(mock_rpc_service_));
+ ON_CALL(mock_rpc_service_, ManageHMICommand(bc_activate_app_request))
.WillByDefault(Return(true));
}
@@ -909,7 +1030,7 @@ class StateControllerImplTest : public ::testing::Test {
am::ApplicationSharedPtr app,
NiceMock<application_manager_test::MockApplication>* app_mock,
am::HmiStatePtr state) {
- EXPECT_CALL(*app_mock, RegularHmiState()).WillOnce(Return(state));
+ ON_CALL(*app_mock, RegularHmiState()).WillByDefault(Return(state));
EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(app)).Times(0);
EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(app->app_id(), _, _))
.Times(0);
@@ -924,47 +1045,112 @@ class StateControllerImplTest : public ::testing::Test {
am::HmiStatePtr NoneNotAudibleState() {
return createHmiState(mobile_apis::HMILevel::HMI_NONE,
mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
mobile_apis::SystemContext::SYSCTXT_MAIN);
}
am::HmiStatePtr FullAudibleState() {
return createHmiState(mobile_apis::HMILevel::HMI_FULL,
mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
mobile_apis::SystemContext::SYSCTXT_MAIN);
}
am::HmiStatePtr FullNotAudibleState() {
return createHmiState(mobile_apis::HMILevel::HMI_FULL,
mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
mobile_apis::SystemContext::SYSCTXT_MAIN);
}
am::HmiStatePtr LimitedState() {
return createHmiState(mobile_apis::HMILevel::HMI_LIMITED,
mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
mobile_apis::SystemContext::SYSCTXT_MAIN);
}
am::HmiStatePtr BackgroundState() {
return createHmiState(mobile_apis::HMILevel::HMI_BACKGROUND,
mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
mobile_apis::SystemContext::SYSCTXT_MAIN);
}
- void CheckStateApplyingForApplication(
- NiceMock<application_manager_test::MockApplication>& application,
+ void ApplyTempStatesForApplication(
+ am::ApplicationSharedPtr app,
+ NiceMock<application_manager_test::MockApplication>& app_mock,
std::vector<am::HmiState::StateID>& state_ids) {
+ using am::event_engine::Event;
using smart_objects::SmartObject;
+ namespace FunctionID = hmi_apis::FunctionID;
+
+ EXPECT_CALL(app_mock, CurrentHmiState())
+ .WillRepeatedly(Return(NoneNotAudibleState()));
+
+ for (size_t i = 0; i < state_ids.size(); ++i) {
+ am::HmiState::StateID state_id = state_ids[i];
+ EXPECT_CALL(app_mock,
+ AddHMIState(Truly(HmiStatesIDComparator(state_id))));
+ 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);
+ break;
+ }
+ case am::HmiState::StateID::STATE_ID_TTS_SESSION: {
+ Event tts_start_event(FunctionID::TTS_Started);
+ state_ctrl_->on_event(tts_start_event);
+ break;
+ }
+ case am::HmiState::StateID::STATE_ID_PHONE_CALL: {
+ 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::event_name] =
+ hmi_apis::Common_EventTypes::PHONE_CALL;
+ phone_call_event.set_smart_object(message);
+ state_ctrl_->on_event(phone_call_event);
+ break;
+ }
+ case am::HmiState::StateID::STATE_ID_SAFETY_MODE: {
+ Event emergency_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::EMERGENCY_EVENT;
+ emergency_event.set_smart_object(message);
+ state_ctrl_->on_event(emergency_event);
+ break;
+ }
+ case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+ state_ctrl_->OnVideoStreamingStarted(app);
+ break;
+ }
+ default:
+ break;
+ }
+ EXPECT_CALL(app_mock, AddHMIState(_)).Times(0);
+ }
+ }
+
+ void CheckStateApplyingForApplication(
+ am::ApplicationSharedPtr app,
+ NiceMock<application_manager_test::MockApplication>& app_mock,
+ std::vector<am::HmiState::StateID>& state_ids) {
using am::event_engine::Event;
+ using smart_objects::SmartObject;
namespace FunctionID = hmi_apis::FunctionID;
- EXPECT_CALL(application, CurrentHmiState())
+ EXPECT_CALL(app_mock, CurrentHmiState())
.WillRepeatedly(Return(NoneNotAudibleState()));
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);
+ EXPECT_CALL(app_mock, AddHMIState(Truly(HmiStatesIDComparator(state_id))))
+ .Times(1);
switch (state_id) {
case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1000,23 +1186,23 @@ class StateControllerImplTest : public ::testing::Test {
break;
}
case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
- state_ctrl_->OnNaviStreamingStarted();
+ state_ctrl_->OnVideoStreamingStarted(app);
break;
}
default:
break;
}
- EXPECT_CALL(application, AddHMIState(_)).Times(0);
+ EXPECT_CALL(app_mock, AddHMIState(_)).Times(0);
}
for (uint32_t i = 0; i < state_ids.size(); ++i) {
am::HmiState::StateID state_id = state_ids[i];
- EXPECT_CALL(application, RemoveHMIState(state_id)).Times(1);
+ EXPECT_CALL(app_mock, RemoveHMIState(state_id)).Times(1);
- EXPECT_CALL(application, PostponedHmiState())
+ EXPECT_CALL(app_mock, PostponedHmiState())
.WillOnce(Return(NoneNotAudibleState()));
- EXPECT_CALL(application, RemovePostponedState());
+ EXPECT_CALL(app_mock, RemovePostponedState());
switch (state_id) {
case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1052,14 +1238,14 @@ class StateControllerImplTest : public ::testing::Test {
break;
}
case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
- state_ctrl_->OnNaviStreamingStopped();
+ state_ctrl_->OnVideoStreamingStopped(app);
break;
}
default:
break;
}
- EXPECT_CALL(application, RemoveHMIState(_)).Times(0);
+ EXPECT_CALL(app_mock, RemoveHMIState(_)).Times(0);
}
}
};
@@ -1111,10 +1297,13 @@ TEST_F(StateControllerImplTest, OnStateChangedToNone) {
HmiStatePtr none_state = createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
SystemContext::SYSCTXT_MAIN);
- HmiStatePtr not_none_state = createHmiState(HMILevel::HMI_FULL,
- AudioStreamingState::NOT_AUDIBLE,
- SystemContext::SYSCTXT_MAIN);
+ HmiStatePtr not_none_state =
+ createHmiState(HMILevel::HMI_FULL,
+ AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
+ SystemContext::SYSCTXT_MAIN);
EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0);
state_ctrl_->OnStateChanged(simple_app_, none_state, not_none_state);
@@ -1126,9 +1315,11 @@ TEST_F(StateControllerImplTest, OnStateChangedToNone) {
TEST_F(StateControllerImplTest, MoveSimpleAppToValidStates) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::INVALID_ENUM,
SystemContext::INVALID_ENUM);
for (std::vector<HmiStatePtr>::iterator it =
@@ -1155,6 +1346,7 @@ TEST_F(StateControllerImplTest, MoveSimpleAppToValidStates) {
TEST_F(StateControllerImplTest, MoveAudioNotResumeAppToValidStates) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
am::ApplicationSharedPtr audio_app = media_navi_vc_app_;
@@ -1163,6 +1355,7 @@ TEST_F(StateControllerImplTest, MoveAudioNotResumeAppToValidStates) {
HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::INVALID_ENUM,
SystemContext::INVALID_ENUM);
for (std::vector<HmiStatePtr>::iterator it =
@@ -1189,6 +1382,7 @@ TEST_F(StateControllerImplTest, MoveAudioNotResumeAppToValidStates) {
TEST_F(StateControllerImplTest, MoveAudioResumeAppToValidStates) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
+ namespace VideoStreamingState = mobile_apis::VideoStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
am::ApplicationSharedPtr audio_app = media_navi_vc_app_;
@@ -1197,6 +1391,7 @@ TEST_F(StateControllerImplTest, MoveAudioResumeAppToValidStates) {
HmiStatePtr initial_state = createHmiState(HMILevel::INVALID_ENUM,
AudioStreamingState::INVALID_ENUM,
+ VideoStreamingState::INVALID_ENUM,
SystemContext::INVALID_ENUM);
// Set all valid states for audio app
@@ -1213,7 +1408,7 @@ TEST_F(StateControllerImplTest, MoveAudioResumeAppToValidStates) {
// 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_,
+ EXPECT_CALL(message_helper_mock_,
SendOnResumeAudioSourceToHMI(media_navi_vc_app_id_, _));
state_to_check->set_audio_streaming_state(AudioStreamingState::AUDIBLE);
@@ -1272,7 +1467,6 @@ TEST_F(StateControllerImplTest, MoveAppFromValidStateToInvalid) {
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<application_manager_test::MockApplication>* app_in_full_mock;
@@ -1301,7 +1495,6 @@ TEST_F(StateControllerImplTest,
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<application_manager_test::MockApplication>* app_in_full_mock =
@@ -1327,7 +1520,6 @@ TEST_F(StateControllerImplTest, SetFullToSimpleAppWhileAudioAppAppIsInFull) {
TEST_F(StateControllerImplTest,
SetFullToAudioAppAppWhileAnotherTypeAudioAppAppIsInFull) {
namespace HMILevel = mobile_apis::HMILevel;
- namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
am::ApplicationSharedPtr app_in_full = media_app_;
@@ -1354,7 +1546,6 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInFull) {
namespace HMILevel = mobile_apis::HMILevel;
- namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
NiceMock<application_manager_test::MockApplication>* app_in_full_mock;
am::ApplicationSharedPtr app_in_full =
@@ -1380,7 +1571,6 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
namespace HMILevel = mobile_apis::HMILevel;
- namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
NiceMock<application_manager_test::MockApplication>* app_in_limited_mock;
@@ -1407,7 +1597,6 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetLimitedToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
namespace HMILevel = mobile_apis::HMILevel;
- namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
NiceMock<application_manager_test::MockApplication>* app_in_limited_mock;
am::ApplicationSharedPtr app_in_limited =
@@ -1435,7 +1624,6 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInLimited) {
namespace HMILevel = mobile_apis::HMILevel;
- namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
am::ApplicationSharedPtr app_in_limited = navi_app_;
@@ -1454,11 +1642,12 @@ TEST_F(StateControllerImplTest,
LimitedState());
ExpectAppWontChangeHmiStateDueToConflictResolving(
app_in_limited, app_in_limited_mock, LimitedState());
+
state_ctrl_->SetRegularState(app_moved_to_limited, LimitedState(), false);
}
TEST_F(StateControllerImplTest,
- SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInFull) {
+ DISABLED_SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInFull) {
namespace HMILevel = mobile_apis::HMILevel;
namespace AudioStreamingState = mobile_apis::AudioStreamingState;
namespace SystemContext = mobile_apis::SystemContext;
@@ -1677,8 +1866,10 @@ TEST_F(StateControllerImplTest,
media_navi_vc_app_ptr_,
BackgroundState(),
FullAudibleState());
- ExpectAppChangeHmiStateDueToConflictResolving(
- media_app_, media_app_ptr_, LimitedState(), BackgroundState());
+
+ EXPECT_CALL(*media_app_ptr_, RegularHmiState())
+ .WillOnce(Return(LimitedState()));
+
ExpectAppChangeHmiStateDueToConflictResolving(
navi_app_, navi_app_ptr_, LimitedState(), BackgroundState());
ExpectAppChangeHmiStateDueToConflictResolving(
@@ -1700,8 +1891,10 @@ TEST_F(StateControllerImplTest,
media_navi_vc_app_ptr_,
BackgroundState(),
FullAudibleState());
- ExpectAppChangeHmiStateDueToConflictResolving(
- media_app_, media_app_ptr_, LimitedState(), BackgroundState());
+
+ EXPECT_CALL(*media_app_ptr_, RegularHmiState())
+ .WillOnce(Return(LimitedState()));
+
ExpectAppChangeHmiStateDueToConflictResolving(
navi_app_, navi_app_ptr_, LimitedState(), BackgroundState());
ExpectAppChangeHmiStateDueToConflictResolving(
@@ -1729,23 +1922,26 @@ TEST_F(StateControllerImplTest, DISABLED_ActivateAppSuccessReceivedFromHMI) {
hmi_states.push_back(
StateLevelPair(createHmiState(HMILevel::HMI_NONE,
AudioStreamingState::NOT_AUDIBLE,
+ VideoStreamingState::NOT_STREAMABLE,
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();
+ std::make_shared<smart_objects::SmartObject>();
(*bc_activate_app_request)[am::strings::params][am::strings::correlation_id] =
corr_id;
for (; it != hmi_states.end(); ++it) {
am::HmiStatePtr hmi_state = it->first;
- am::HmiStatePtr initial_hmi_state = it->first;
+ am::HmiStatePtr initial_hmi_state = it2->first;
Common_HMILevel::eType hmi_level = it->second;
SetBCActivateAppRequestToHMI(hmi_level, corr_id);
- ON_CALL(app_manager_mock_, ManageHMICommand(bc_activate_app_request))
+ ON_CALL(app_manager_mock_, GetRPCService())
+ .WillByDefault(ReturnRef(mock_rpc_service_));
+ ON_CALL(mock_rpc_service_, ManageHMICommand(bc_activate_app_request))
.WillByDefault(Return(true));
EXPECT_CALL(app_manager_mock_, application_id(corr_id))
@@ -1852,49 +2048,55 @@ TEST_F(StateControllerImplTest, ActivateAppInvalidCorrelationId) {
state_ctrl_->on_event(event);
}
-TEST_F(StateControllerImplTest, ApplyTempStatesForSimpleApp) {
+TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForSimpleApp) {
InsertApplication(simple_app_);
- CheckStateApplyingForApplication(*simple_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ simple_app_, *simple_app_ptr_, valid_state_ids_);
}
-TEST_F(StateControllerImplTest, ApplyTempStatesForMediaApp) {
+TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForMediaApp) {
InsertApplication(media_app_);
- CheckStateApplyingForApplication(*media_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ media_app_, *media_app_ptr_, valid_state_ids_);
}
TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) {
InsertApplication(navi_app_);
- CheckStateApplyingForApplication(*navi_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(navi_app_, *navi_app_ptr_, valid_state_ids_);
}
-TEST_F(StateControllerImplTest, ApplyTempStatesForVCApp) {
+TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForVCApp) {
InsertApplication(vc_app_);
- CheckStateApplyingForApplication(*vc_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(vc_app_, *vc_app_ptr_, valid_state_ids_);
}
TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) {
InsertApplication(media_navi_app_);
- CheckStateApplyingForApplication(*media_navi_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ media_navi_app_, *media_navi_app_ptr_, valid_state_ids_);
}
-TEST_F(StateControllerImplTest, ApplyTempStatesForMediaVCApp) {
+TEST_F(StateControllerImplTest, DISABLED_ApplyTempStatesForMediaVCApp) {
InsertApplication(media_vc_app_);
- CheckStateApplyingForApplication(*media_vc_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ media_vc_app_, *media_vc_app_ptr_, valid_state_ids_);
}
TEST_F(StateControllerImplTest, ApplyTempStatesForNaviVCApp) {
InsertApplication(navi_vc_app_);
- CheckStateApplyingForApplication(*navi_vc_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ navi_vc_app_, *navi_vc_app_ptr_, valid_state_ids_);
}
TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviVCApp) {
InsertApplication(media_navi_vc_app_);
- CheckStateApplyingForApplication(*media_navi_vc_app_ptr_, valid_state_ids_);
+ CheckStateApplyingForApplication(
+ media_navi_vc_app_, *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_);
+ am::HmiStatePtr state_phone_call =
+ std::make_shared<am::PhoneCallHmiState>(simple_app_, app_manager_mock_);
TestSetState(simple_app_,
state_phone_call,
APP_TYPE_NON_MEDIA,
@@ -1902,8 +2104,8 @@ TEST_F(StateControllerImplTest, SetStatePhoneCallForNonMediaApplication) {
}
TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaApplication) {
- am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
- media_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_phone_call =
+ std::make_shared<am::PhoneCallHmiState>(media_app_, app_manager_mock_);
TestSetState(media_app_,
state_phone_call,
APP_TYPE_MEDIA,
@@ -1911,8 +2113,8 @@ TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaApplication) {
}
TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaNaviApplication) {
- am::HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
- media_navi_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_phone_call = std::make_shared<am::PhoneCallHmiState>(
+ media_navi_app_, app_manager_mock_);
TestSetState(media_navi_app_,
state_phone_call,
APP_TYPE_NAVI,
@@ -1921,7 +2123,7 @@ TEST_F(StateControllerImplTest, SetStatePhoneCallForMediaNaviApplication) {
TEST_F(StateControllerImplTest, SetVRStateForNonMediaApplication) {
am::HmiStatePtr state_vr =
- utils::MakeShared<am::VRHmiState>(simple_app_id_, app_manager_mock_);
+ std::make_shared<am::VRHmiState>(simple_app_, app_manager_mock_);
TestSetState(simple_app_,
state_vr,
APP_TYPE_NON_MEDIA,
@@ -1930,7 +2132,7 @@ TEST_F(StateControllerImplTest, SetVRStateForNonMediaApplication) {
TEST_F(StateControllerImplTest, SetVRStateForMediaApplication) {
am::HmiStatePtr state_vr =
- utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_);
+ std::make_shared<am::VRHmiState>(media_app_, app_manager_mock_);
TestSetState(media_app_,
state_vr,
APP_TYPE_MEDIA,
@@ -1938,8 +2140,8 @@ TEST_F(StateControllerImplTest, SetVRStateForMediaApplication) {
}
TEST_F(StateControllerImplTest, SetVRStateForMediaNaviVoiceApplication) {
- am::HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>(
- media_navi_vc_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_vr =
+ std::make_shared<am::VRHmiState>(media_navi_vc_app_, app_manager_mock_);
TestSetState(media_navi_vc_app_,
state_vr,
APP_TYPE_MEDIA,
@@ -1949,7 +2151,7 @@ TEST_F(StateControllerImplTest, SetVRStateForMediaNaviVoiceApplication) {
TEST_F(StateControllerImplTest,
SetTTSStateForNonMediaApplicationAttenuatedNotSupported) {
am::HmiStatePtr state_tts =
- utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_);
+ std::make_shared<am::TTSHmiState>(simple_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
TestSetState(simple_app_,
@@ -1961,7 +2163,7 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetTTSStateForNonMediaApplicationAttenuatedSupported) {
am::HmiStatePtr state_tts =
- utils::MakeShared<am::TTSHmiState>(simple_app_id_, app_manager_mock_);
+ std::make_shared<am::TTSHmiState>(simple_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
TestSetState(simple_app_,
@@ -1973,7 +2175,7 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetTTSStateForMediaApplicationAttenuatedNotSupported) {
am::HmiStatePtr state_tts =
- utils::MakeShared<am::TTSHmiState>(media_app_id_, app_manager_mock_);
+ std::make_shared<am::TTSHmiState>(media_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
TestSetState(media_app_,
@@ -1985,7 +2187,7 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetTTSStateForMediaApplicationAttenuatedSupported) {
am::HmiStatePtr state_tts =
- utils::MakeShared<am::TTSHmiState>(media_app_id_, app_manager_mock_);
+ std::make_shared<am::TTSHmiState>(media_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
TestSetState(media_app_,
@@ -1996,8 +2198,8 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetTTSStateForMediaNaviVCApplicationAttenuatedNotSupported) {
- am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
- media_navi_vc_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_tts =
+ std::make_shared<am::TTSHmiState>(media_navi_vc_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
TestSetState(media_navi_vc_app_,
@@ -2008,8 +2210,8 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest,
SetTTSStateForMediaNaviVCApplicationAttenuatedSupported) {
- am::HmiStatePtr state_tts = utils::MakeShared<am::TTSHmiState>(
- media_navi_vc_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_tts =
+ std::make_shared<am::TTSHmiState>(media_navi_vc_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
TestSetState(media_navi_vc_app_,
@@ -2020,7 +2222,7 @@ TEST_F(StateControllerImplTest,
TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(simple_app_id_,
+ std::make_shared<am::VideoStreamingHmiState>(simple_app_,
app_manager_mock_);
TestSetState(simple_app_,
state_navi_streming,
@@ -2029,9 +2231,9 @@ TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) {
}
TEST_F(StateControllerImplTest,
- SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
+ DISABLED_SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
+ std::make_shared<am::VideoStreamingHmiState>(media_app_,
app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
@@ -2042,9 +2244,9 @@ TEST_F(StateControllerImplTest,
}
TEST_F(StateControllerImplTest,
- SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
+ DISABLED_SetNaviStreamingStateMediaApplicationAttenuatedSupported) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(media_app_id_,
+ std::make_shared<am::VideoStreamingHmiState>(media_app_,
app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
@@ -2055,10 +2257,9 @@ TEST_F(StateControllerImplTest,
}
TEST_F(StateControllerImplTest,
- SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
+ DISABLED_SetNaviStreamingStateVCApplicationAttenuatedNotSupported) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
- app_manager_mock_);
+ std::make_shared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
TestSetState(vc_app_,
@@ -2068,10 +2269,9 @@ TEST_F(StateControllerImplTest,
}
TEST_F(StateControllerImplTest,
- SetNaviStreamingStateVCApplicationAttenuatedSupported) {
+ DISABLED_SetNaviStreamingStateVCApplicationAttenuatedSupported) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(vc_app_id_,
- app_manager_mock_);
+ std::make_shared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_);
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
TestSetState(vc_app_,
@@ -2080,9 +2280,9 @@ TEST_F(StateControllerImplTest,
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
-TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) {
+TEST_F(StateControllerImplTest, DISABLED_SetNaviStreamingStateNaviApplication) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(navi_app_id_,
+ std::make_shared<am::VideoStreamingHmiState>(navi_app_,
app_manager_mock_);
TestSetState(navi_app_,
state_navi_streming,
@@ -2090,9 +2290,10 @@ TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) {
&StateControllerImplTest::PrepareNaviStreamingHMIStateResults);
}
-TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) {
+TEST_F(StateControllerImplTest,
+ DISABLED_SetNaviStreamingStateMediaNaviApplication) {
am::HmiStatePtr state_navi_streming =
- utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_id_,
+ std::make_shared<am::VideoStreamingHmiState>(media_navi_app_,
app_manager_mock_);
TestSetState(media_navi_app_,
state_navi_streming,
@@ -2101,8 +2302,8 @@ TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) {
}
TEST_F(StateControllerImplTest, SetSafetyModeStateForNonMediaApplication) {
- am::HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>(
- simple_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_safety_mode =
+ std::make_shared<am::SafetyModeHmiState>(simple_app_, app_manager_mock_);
TestSetState(simple_app_,
state_safety_mode,
APP_TYPE_NON_MEDIA,
@@ -2111,7 +2312,7 @@ TEST_F(StateControllerImplTest, SetSafetyModeStateForNonMediaApplication) {
TEST_F(StateControllerImplTest, SetSafetyModeStateForMediaApplication) {
am::HmiStatePtr state_safety_mode =
- utils::MakeShared<am::VRHmiState>(media_app_id_, app_manager_mock_);
+ std::make_shared<am::VRHmiState>(media_app_, app_manager_mock_);
TestSetState(media_app_,
state_safety_mode,
APP_TYPE_MEDIA,
@@ -2120,8 +2321,8 @@ TEST_F(StateControllerImplTest, SetSafetyModeStateForMediaApplication) {
TEST_F(StateControllerImplTest,
SetSafetyModeStateForMediaNaviVoiceApplication) {
- am::HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>(
- media_navi_vc_app_id_, app_manager_mock_);
+ am::HmiStatePtr state_safety_mode =
+ std::make_shared<am::VRHmiState>(media_navi_vc_app_, app_manager_mock_);
TestSetState(media_navi_vc_app_,
state_safety_mode,
APP_TYPE_MEDIA,
@@ -2154,7 +2355,7 @@ TEST_F(StateControllerImplTest,
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
- TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::PhoneCallHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PreparePhoneCallHMIStateResults);
}
@@ -2163,7 +2364,7 @@ TEST_F(StateControllerImplTest,
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
- TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::PhoneCallHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PreparePhoneCallHMIStateResults);
}
@@ -2192,7 +2393,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedNotSupported) {
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
- TestMixState<am::VRHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::VRHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
@@ -2200,7 +2401,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedSupported) {
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
- TestMixState<am::VRHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::VRHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
@@ -2214,7 +2415,7 @@ TEST_F(StateControllerImplTest,
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
- TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::TTSHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
@@ -2222,7 +2423,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithTTSAttenueatedSupported) {
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
- TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::TTSHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareNaviStreamTTSStateResult);
}
@@ -2247,7 +2448,7 @@ TEST_F(StateControllerImplTest,
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(false));
- TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::SafetyModeHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
@@ -2256,7 +2457,7 @@ TEST_F(StateControllerImplTest,
EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
.WillRepeatedly(Return(true));
- TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>(
+ TestMixState<am::SafetyModeHmiState, am::VideoStreamingHmiState>(
&StateControllerImplTest::PrepareVRTTSHMIStateResults);
}
@@ -2308,6 +2509,7 @@ TEST_F(StateControllerImplTest, SetRegularStateWithAudioStateAudible) {
HmiStatePtr check_state = createHmiState(HMILevel::HMI_BACKGROUND,
AudioStreamingState::AUDIBLE,
+ VideoStreamingState::STREAMABLE,
SystemContext::SYSCTXT_MAIN);
EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
.WillRepeatedly(Return(BackgroundState()));
@@ -2318,7 +2520,9 @@ TEST_F(StateControllerImplTest, SetRegularStateWithAudioStateAudible) {
EXPECT_CALL(*simple_app_ptr_,
SetRegularState(Truly(HmiStatesComparator(check_state))));
- state_ctrl_->SetRegularState(simple_app_, AudioStreamingState::AUDIBLE);
+ state_ctrl_->SetRegularState(simple_app_,
+ AudioStreamingState::AUDIBLE,
+ VideoStreamingState::STREAMABLE);
}
TEST_F(StateControllerImplTest,
@@ -2372,7 +2576,7 @@ TEST_F(StateControllerImplTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false));
- EXPECT_CALL(*message_helper_mock_,
+ EXPECT_CALL(message_helper_mock_,
SendOnResumeAudioSourceToHMI(simple_app_id_, _)).Times(0);
EXPECT_CALL(*simple_app_ptr_,
SetPostponedState(Truly(HmiStatesComparator(check_state))))
@@ -2390,7 +2594,7 @@ TEST_F(StateControllerImplTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
- EXPECT_CALL(*message_helper_mock_,
+ EXPECT_CALL(message_helper_mock_,
SendOnResumeAudioSourceToHMI(media_app_id_, _));
EXPECT_CALL(*media_app_ptr_,
SetPostponedState(Truly(HmiStatesComparator(check_state))))
@@ -2478,6 +2682,505 @@ TEST_F(StateControllerImplTest,
state_ctrl_->SetRegularState(media_app_, check_state, false);
}
+TEST_F(StateControllerImplTest,
+ SetStateForNaviApp_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 hmi_state = FullAudibleState();
+
+ EXPECT_CALL(*navi_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
+
+ EXPECT_CALL(*navi_app_ptr_, is_navi()).WillRepeatedly(Return(true));
+
+ EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
+ .WillRepeatedly(Return(false));
+
+ EXPECT_CALL(*navi_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(hmi_state));
+
+ EXPECT_CALL(app_manager_mock_, active_application())
+ .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+
+ state_ctrl_->SetRegularState(navi_app_, hmi_state, false);
+}
+
+TEST_F(StateControllerImplTest,
+ SetStateForNaviApp_BCOnPhoneCall_NotPostponedState) {
+ 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] = false;
+ 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 hmi_state = FullAudibleState();
+
+ EXPECT_CALL(*navi_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
+
+ EXPECT_CALL(*navi_app_ptr_, is_navi()).WillRepeatedly(Return(true));
+
+ EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
+ .WillRepeatedly(Return(false));
+
+ EXPECT_CALL(*navi_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(hmi_state));
+
+ EXPECT_CALL(app_manager_mock_, active_application())
+ .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+
+ EXPECT_CALL(*navi_app_ptr_, SetPostponedState(_)).Times(0);
+
+ state_ctrl_->SetRegularState(navi_app_, hmi_state, false);
+}
+
+TEST_F(StateControllerImplTest,
+ SetStateForNaviApp_BCOnPhoneCall_SetPostponedStateWithActivation) {
+ using namespace hmi_apis;
+ using namespace smart_objects;
+ using namespace am::event_engine;
+ using namespace constants;
+
+ const uint32_t app_id = navi_app_->app_id();
+ // 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 hmi_state = FullAudibleState();
+
+ EXPECT_CALL(*navi_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
+ EXPECT_CALL(*navi_app_ptr_, is_navi()).WillRepeatedly(Return(true));
+ EXPECT_CALL(*navi_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+
+ SetBCActivateAppRequestToHMI(hmi_apis::Common_HMILevel::FULL, kCorrID);
+
+ EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
+ .WillRepeatedly(Return(false));
+
+ EXPECT_CALL(*navi_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(hmi_state));
+
+ EXPECT_CALL(app_manager_mock_, active_application())
+ .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+
+ state_ctrl_->SetRegularState(navi_app_, hmi_state, true);
+}
+
+TEST_F(StateControllerImplTest,
+ SetStateForNaviApp_BCOnPhoneCall_NotPostponedStateWithActivation) {
+ using namespace hmi_apis;
+ using namespace smart_objects;
+ using namespace am::event_engine;
+ using namespace constants;
+
+ const uint32_t app_id = navi_app_->app_id();
+ // Precondition
+ Event 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::event_name] =
+ hmi_apis::Common_EventTypes::PHONE_CALL;
+
+ event.set_smart_object(message);
+ state_ctrl_->on_event(event);
+
+ am::HmiStatePtr hmi_state = FullAudibleState();
+
+ EXPECT_CALL(*navi_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
+ EXPECT_CALL(*navi_app_ptr_, is_navi()).WillRepeatedly(Return(true));
+ EXPECT_CALL(*navi_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+
+ SetBCActivateAppRequestToHMI(hmi_apis::Common_HMILevel::FULL, kCorrID);
+
+ EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
+ .WillRepeatedly(Return(false));
+
+ EXPECT_CALL(*navi_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(hmi_state));
+
+ EXPECT_CALL(app_manager_mock_, active_application())
+ .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+
+ EXPECT_CALL(*navi_app_ptr_, SetPostponedState(_)).Times(0);
+
+ state_ctrl_->SetRegularState(navi_app_, hmi_state, true);
+}
+
+TEST_F(StateControllerImplTest, OnEventChangedAudioSourceAppRemainInFull) {
+ const uint32_t app_id = simple_app_->app_id();
+ InsertApplication(simple_app_);
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ msg[am::strings::msg_params][am::hmi_notification::is_active] = true;
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnEventChanged;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+
+ const HmiStatePtr state =
+ createHmiState(mobile_apis::HMILevel::HMI_FULL,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN);
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).WillOnce(Return(state));
+ EXPECT_CALL(*simple_app_ptr_, IsAudioApplication())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillOnce(Return(FullAudibleState()));
+
+ HmiStatePtr new_state;
+ EXPECT_CALL(*simple_app_ptr_, AddHMIState(_))
+ .WillOnce(SaveArg<0>(&new_state));
+
+ state_ctrl_->on_event(event);
+
+ EXPECT_EQ(new_state->hmi_level(), mobile_apis::HMILevel::HMI_FULL);
+ EXPECT_EQ(new_state->audio_streaming_state(),
+ mobile_apis::AudioStreamingState::NOT_AUDIBLE);
+}
+
+TEST_F(StateControllerImplTest, OnEventChangedAudioSourceAppToBackground) {
+ const uint32_t app_id = simple_app_->app_id();
+ InsertApplication(simple_app_);
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ msg[am::strings::msg_params][am::hmi_notification::is_active] = true;
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnEventChanged;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+
+ const HmiStatePtr state =
+ createHmiState(mobile_apis::HMILevel::HMI_LIMITED,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN);
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).WillOnce(Return(state));
+ EXPECT_CALL(*simple_app_ptr_, IsAudioApplication())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillOnce(Return(LimitedState()));
+
+ HmiStatePtr new_state;
+ EXPECT_CALL(*simple_app_ptr_, AddHMIState(_))
+ .WillOnce(SaveArg<0>(&new_state));
+
+ state_ctrl_->on_event(event);
+
+ EXPECT_EQ(new_state->hmi_level(), mobile_apis::HMILevel::HMI_BACKGROUND);
+ EXPECT_EQ(new_state->audio_streaming_state(),
+ mobile_apis::AudioStreamingState::NOT_AUDIBLE);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppDeactivatedIncorrectHmiLevel) {
+ smart_objects::SmartObject msg;
+ const uint32_t app_id = simple_app_->app_id();
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppDeactivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ EXPECT_CALL(app_manager_mock_, application(app_id))
+ .WillOnce(Return(simple_app_));
+ EXPECT_CALL(*simple_app_ptr_, hmi_level())
+ .WillOnce(Return(mobile_apis::HMILevel::HMI_BACKGROUND));
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0);
+ state_ctrl_->on_event(event);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppDeactivatedIncorrectApp) {
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = 0;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppDeactivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ const am::ApplicationSharedPtr incorrect_app;
+ EXPECT_CALL(app_manager_mock_, application(_))
+ .WillOnce(Return(incorrect_app));
+ EXPECT_CALL(*simple_app_ptr_, hmi_level()).Times(0);
+ state_ctrl_->on_event(event);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppDeactivatedAudioApplication) {
+ const uint32_t app_id = simple_app_->app_id();
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppDeactivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ const HmiStatePtr state =
+ createHmiState(mobile_apis::HMILevel::HMI_LIMITED,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN);
+ // OnAppDeactivated
+ EXPECT_CALL(app_manager_mock_, application(app_id))
+ .WillOnce(Return(simple_app_));
+ EXPECT_CALL(*simple_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+ EXPECT_CALL(*simple_app_ptr_, hmi_level())
+ .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+ // DeactivateApp
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).WillOnce(Return(state));
+ EXPECT_CALL(*simple_app_ptr_, IsAudioApplication())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillOnce(Return(BackgroundState()))
+ .WillOnce(Return(BackgroundState()));
+ state_ctrl_->on_event(event);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppDeactivatedNotAudioApplication) {
+ const uint32_t app_id = simple_app_->app_id();
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppDeactivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ const HmiStatePtr state =
+ createHmiState(mobile_apis::HMILevel::HMI_BACKGROUND,
+ mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN);
+ // OnAppDeactivated
+ EXPECT_CALL(app_manager_mock_, application(app_id))
+ .WillOnce(Return(simple_app_));
+ EXPECT_CALL(*simple_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+ EXPECT_CALL(*simple_app_ptr_, hmi_level())
+ .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+ // DeactivateApp
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).WillOnce(Return(state));
+ EXPECT_CALL(*simple_app_ptr_, IsAudioApplication())
+ .WillRepeatedly(Return(false));
+
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillOnce(Return(BackgroundState()))
+ .WillOnce(Return(BackgroundState()));
+ state_ctrl_->on_event(event);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppActivatedIncorrectApp) {
+ smart_objects::SmartObject msg;
+ const uint32_t incorrect_app_ID = 0;
+ msg[am::strings::msg_params][am::strings::app_id] = incorrect_app_ID;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppActivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ const am::ApplicationSharedPtr incorrect_app;
+ EXPECT_CALL(app_manager_mock_, application(_))
+ .WillOnce(Return(incorrect_app));
+ EXPECT_CALL(*simple_app_ptr_, app_id()).Times(0);
+ state_ctrl_->on_event(event);
+}
+
+TEST_F(StateControllerImplTest, OnEventOnAppActivated) {
+ using namespace constants;
+
+ smart_objects::SmartObject msg;
+ for (std::vector<am::ApplicationSharedPtr>::const_iterator it =
+ applications_list_.begin();
+ it != applications_list_.end();
+ ++it) {
+ uint32_t app_id = (*it)->app_id();
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnAppActivated;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+
+ EXPECT_CALL(app_manager_mock_, application(app_id)).WillOnce(Return(*it));
+ // SetRegularState
+ EXPECT_CALL(*simple_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+ EXPECT_CALL(*simple_app_ptr_, IsAudioApplication())
+ .WillRepeatedly(Return(true));
+
+ smart_objects::SmartObjectSPtr activate_app =
+ std::make_shared<smart_objects::SmartObject>();
+ (*activate_app)[am::strings::params][am::strings::correlation_id] = kCorrID;
+ SetBCActivateAppRequestToHMI(hmi_apis::Common_HMILevel::FULL, kCorrID);
+ state_ctrl_->on_event(event);
+ }
+}
+
+TEST_F(StateControllerImplTest, IsStateActive) {
+ HmiStatePtr state =
+ createHmiState(mobile_apis::HMILevel::HMI_FULL,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN);
+ state->set_state_id(HmiState::STATE_ID_CURRENT);
+ EXPECT_TRUE(state_ctrl_->IsStateActive(state->state_id()));
+ state->set_state_id(HmiState::STATE_ID_REGULAR);
+ EXPECT_TRUE(state_ctrl_->IsStateActive(state->state_id()));
+ state->set_state_id(HmiState::STATE_ID_TTS_SESSION);
+ EXPECT_FALSE(state_ctrl_->IsStateActive(state->state_id()));
+}
+
+TEST_F(StateControllerImplTest, DISABLED_IsStateActiveApplyCorrectTempStates) {
+ InsertApplication(simple_app_);
+ ApplyTempStatesForApplication(
+ simple_app_, *simple_app_ptr_, valid_state_ids_);
+ std::vector<am::HmiState::StateID>::const_iterator it =
+ valid_state_ids_.begin();
+ for (; it != valid_state_ids_.end(); ++it) {
+ EXPECT_TRUE(state_ctrl_->IsStateActive(*it));
+ }
+}
+
+TEST_F(StateControllerImplTest, IsStateActiveApplyNotCorrectTempStates) {
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+ const hmi_apis::FunctionID::eType event_id = hmi_apis::FunctionID::VR_Started;
+ am::event_engine::Event event(event_id);
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+ EXPECT_FALSE(state_ctrl_->IsStateActive(HmiState::STATE_ID_AUDIO_SOURCE));
+}
+
+TEST_F(StateControllerImplTest, OnApplicationRegisteredDifferentStates) {
+ const uint32_t app_id = simple_app_->app_id();
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ msg[am::strings::msg_params][am::hmi_notification::is_active] = true;
+
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnEventChanged;
+ am::event_engine::Event event(event_id);
+
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::PHONE_CALL;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::DEACTIVATE_HMI;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::EMBEDDED_NAVI;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+
+ const am::HmiStatePtr old_state = CreateHmiStateByHmiStateType<am::HmiState>(
+ mobile_apis::HMILevel::HMI_FULL,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN,
+ simple_app_);
+
+ EXPECT_CALL(*simple_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(old_state));
+ EXPECT_CALL(*simple_app_ptr_, AddHMIState(_)).Times(4);
+
+ const am::HmiStatePtr default_state =
+ CreateHmiStateByHmiStateType<am::HmiState>(
+ mobile_apis::HMILevel::HMI_BACKGROUND,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN,
+ simple_app_);
+
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).WillOnce(Return(old_state));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(default_state));
+
+ EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0);
+ EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(_));
+ EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _));
+
+ state_ctrl_->OnApplicationRegistered(simple_app_,
+ mobile_apis::HMILevel::HMI_BACKGROUND);
+}
+
+TEST_F(StateControllerImplTest, OnApplicationRegisteredEqualStates) {
+ const uint32_t app_id = simple_app_->app_id();
+ smart_objects::SmartObject msg;
+ msg[am::strings::msg_params][am::strings::app_id] = app_id;
+ msg[am::strings::msg_params][am::hmi_notification::is_active] = true;
+
+ const hmi_apis::FunctionID::eType event_id =
+ hmi_apis::FunctionID::BasicCommunication_OnEventChanged;
+ am::event_engine::Event event(event_id);
+
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::AUDIO_SOURCE;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+ msg[am::strings::msg_params][am::hmi_notification::event_name] =
+ hmi_apis::Common_EventTypes::PHONE_CALL;
+ event.set_smart_object(msg);
+ state_ctrl_->on_event(event);
+
+ const am::HmiStatePtr old_state = CreateHmiStateByHmiStateType<am::HmiState>(
+ mobile_apis::HMILevel::HMI_FULL,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN,
+ simple_app_);
+
+ EXPECT_CALL(*simple_app_ptr_, app_id()).WillRepeatedly(Return(app_id));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(old_state));
+ EXPECT_CALL(*simple_app_ptr_, AddHMIState(_)).Times(2);
+
+ const am::HmiStatePtr default_state =
+ CreateHmiStateByHmiStateType<am::HmiState>(
+ mobile_apis::HMILevel::HMI_BACKGROUND,
+ mobile_apis::AudioStreamingState::AUDIBLE,
+ mobile_apis::VideoStreamingState::NOT_STREAMABLE,
+ mobile_apis::SystemContext::SYSCTXT_MAIN,
+ simple_app_);
+ EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
+ .WillOnce(Return(default_state));
+ EXPECT_CALL(*simple_app_ptr_, CurrentHmiState())
+ .WillRepeatedly(Return(default_state));
+
+ EXPECT_CALL(*simple_app_ptr_, ResetDataInNone()).Times(0);
+ EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(_)).Times(0);
+ EXPECT_CALL(app_manager_mock_, OnHMILevelChanged(_, _, _)).Times(0);
+
+ state_ctrl_->OnApplicationRegistered(simple_app_,
+ mobile_apis::HMILevel::HMI_BACKGROUND);
+}
+
} // namespace state_controller_test
} // namespace components
} // namespace test
View Lorry Controller Status