diff options
Diffstat (limited to 'src/components/application_manager/test/resumption')
4 files changed, 690 insertions, 177 deletions
diff --git a/src/components/application_manager/test/resumption/resume_ctrl_test.cc b/src/components/application_manager/test/resumption/resume_ctrl_test.cc index f3e49001fa..1c2339096c 100644 --- a/src/components/application_manager/test/resumption/resume_ctrl_test.cc +++ b/src/components/application_manager/test/resumption/resume_ctrl_test.cc @@ -37,12 +37,15 @@ #include "application_manager/resumption/resume_ctrl_impl.h" #include "application_manager/usage_statistics.h" #include "application_manager/mock_application.h" +#include "application_manager/mock_app_extension.h" +#include "application_manager/mock_help_prompt_manager.h" #include "application_manager/mock_resumption_data.h" #include "interfaces/MOBILE_API.h" #include "application_manager/application_manager_impl.h" #include "application_manager/application.h" #include "utils/data_accessor.h" -#include "utils/make_shared.h" +#include "config_profile/profile.h" + #include "application_manager/mock_message_helper.h" #include "application_manager/mock_application_manager.h" #include "application_manager/mock_application_manager_settings.h" @@ -55,14 +58,16 @@ namespace resumption_test { using ::testing::_; using ::testing::A; -using ::testing::Return; -using ::testing::ReturnRef; +using ::testing::AtLeast; using ::testing::DoAll; -using ::testing::SetArgReferee; +using ::testing::Eq; using ::testing::Mock; using ::testing::NiceMock; -using ::testing::AtLeast; -using ::testing::Eq; +using ::testing::Return; +using ::testing::ReturnRef; +using ::testing::SetArgReferee; +using ::testing::ReturnPointee; +using ::testing::SaveArg; using namespace application_manager_test; using namespace resumption; @@ -80,51 +85,87 @@ class ResumeCtrlTest : public ::testing::Test { , kTestGrammarId_(10) , kHash_("saved_hash") , kAppResumingTimeout_(30000u) // miliseconds - , kTestTimeStamp_(1452074434u) {} + , kTestTimeStamp_(1452074434u) + , app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>()) + , kDefaultDeferredTestLevel_(eType::INVALID_ENUM) + , kNaviLowbandwidthLevel_("LIMITED") + , kProjectionLowbandwidthLevel_("NONE") + , kMediaLowbandwidthLevel_("NONE") { + profile::Profile profile_; + profile_.set_config_file_name("smartDeviceLink.ini"); + resumption_delay_before_ign_ = profile_.resumption_delay_before_ign(); + } virtual void SetUp() OVERRIDE { - Mock::VerifyAndClearExpectations(&app_mngr_); - ON_CALL(app_mngr_, event_dispatcher()) + Mock::VerifyAndClearExpectations(&mock_app_mngr_); + ON_CALL(mock_app_mngr_, event_dispatcher()) .WillByDefault(ReturnRef(mock_event_dispatcher_)); mock_storage_ = - ::utils::MakeShared<NiceMock<resumption_test::MockResumptionData> >( - app_mngr_); - app_mock_ = utils::MakeShared<NiceMock<MockApplication> >(); + std::make_shared<NiceMock<resumption_test::MockResumptionData> >( + mock_app_mngr_); + mock_app_ = std::make_shared<NiceMock<MockApplication> >(); + mock_help_prompt_manager_ = + std::shared_ptr<MockHelpPromptManager>(new MockHelpPromptManager()); + mock_app_extension_ = std::make_shared< + NiceMock<application_manager_test::MockAppExtension> >(); const_app_ = - static_cast<application_manager::ApplicationConstSharedPtr>(app_mock_); - res_ctrl_ = utils::MakeShared<ResumeCtrlImpl>(app_mngr_); + static_cast<application_manager::ApplicationConstSharedPtr>(mock_app_); + res_ctrl_ = std::make_shared<ResumeCtrlImpl>(mock_app_mngr_); res_ctrl_->set_resumption_storage(mock_storage_); - ON_CALL(app_mngr_, state_controller()) - .WillByDefault(ReturnRef(state_controller_)); - ON_CALL(app_mngr_, get_settings()) + ON_CALL(mock_app_mngr_, state_controller()) + .WillByDefault(ReturnRef(mock_state_controller_)); + ON_CALL(mock_app_mngr_, get_settings()) .WillByDefault(ReturnRef(mock_application_manager_settings_)); + EXPECT_CALL(mock_app_mngr_, CheckResumptionRequiredTransportAvailable(_)) + .Times(AtLeast(0)) + .WillRepeatedly(Return(true)); ON_CALL(mock_application_manager_settings_, use_db_for_resumption()) .WillByDefault(Return(false)); ON_CALL(mock_application_manager_settings_, app_resuming_timeout()) .WillByDefault(ReturnRef(kAppResumingTimeout_)); + // use EXPECTED_CALL().Times(AtLeast(0)) instead of ON_CALL to remove + // warning messages + EXPECT_CALL(mock_application_manager_settings_, + navigation_lowbandwidth_resumption_level()) + .Times(AtLeast(0)) + .WillRepeatedly(ReturnRef(kNaviLowbandwidthLevel_)); + EXPECT_CALL(mock_application_manager_settings_, + projection_lowbandwidth_resumption_level()) + .Times(AtLeast(0)) + .WillRepeatedly(ReturnRef(kProjectionLowbandwidthLevel_)); + EXPECT_CALL(mock_application_manager_settings_, + media_lowbandwidth_resumption_level()) + .Times(AtLeast(0)) + .WillRepeatedly(ReturnRef(kMediaLowbandwidthLevel_)); + + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .Times(AtLeast(0)) + .WillRepeatedly(Return(kDefaultDeferredTestLevel_)); } void TearDown() OVERRIDE { - Mock::VerifyAndClearExpectations(&app_mngr_); + Mock::VerifyAndClearExpectations(&mock_app_mngr_); } void GetInfoFromApp() { - ON_CALL(*app_mock_, policy_app_id()) + ON_CALL(*mock_app_, policy_app_id()) .WillByDefault(Return(kTestPolicyAppId_)); - ON_CALL(*app_mock_, mac_address()).WillByDefault(ReturnRef(kMacAddress_)); - ON_CALL(*app_mock_, device()).WillByDefault(Return(kTestDevId_)); - ON_CALL(*app_mock_, app_id()).WillByDefault(Return(kTestAppId_)); + ON_CALL(*mock_app_, mac_address()).WillByDefault(ReturnRef(kMacAddress_)); + ON_CALL(*mock_app_, device()).WillByDefault(Return(kTestDevId_)); + ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kTestAppId_)); } NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_; application_manager_test::MockApplicationManagerSettings mock_application_manager_settings_; - application_manager_test::MockApplicationManager app_mngr_; - MockStateController state_controller_; - utils::SharedPtr<ResumeCtrl> res_ctrl_; - utils::SharedPtr<NiceMock<resumption_test::MockResumptionData> > - mock_storage_; - utils::SharedPtr<NiceMock<MockApplication> > app_mock_; + NiceMock<application_manager_test::MockApplicationManager> mock_app_mngr_; + std::shared_ptr<NiceMock<application_manager_test::MockAppExtension> > + mock_app_extension_; + MockStateController mock_state_controller_; + std::shared_ptr<ResumeCtrl> res_ctrl_; + std::shared_ptr<NiceMock<resumption_test::MockResumptionData> > mock_storage_; + std::shared_ptr<NiceMock<MockApplication> > mock_app_; + std::shared_ptr<MockHelpPromptManager> mock_help_prompt_manager_; application_manager::ApplicationConstSharedPtr const_app_; const uint32_t kTestAppId_; const std::string kTestPolicyAppId_; @@ -136,7 +177,13 @@ class ResumeCtrlTest : public ::testing::Test { const std::string kHash_; const uint32_t kAppResumingTimeout_; const uint32_t kTestTimeStamp_; + uint32_t resumption_delay_before_ign_; + std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_; sync_primitives::Lock app_set_lock_; + const mobile_apis::HMILevel::eType kDefaultDeferredTestLevel_; + const std::string kNaviLowbandwidthLevel_; + const std::string kProjectionLowbandwidthLevel_; + const std::string kMediaLowbandwidthLevel_; }; /** @@ -151,15 +198,15 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGrammarId) { // Check RestoreApplicationData GetInfoFromApp(); - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, UpdateHash()); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, UpdateHash()); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -175,16 +222,16 @@ TEST_F(ResumeCtrlTest, StartResumption_WithoutGrammarId) { saved_app[application_manager::strings::hash_id] = kHash_; GetInfoFromApp(); - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); // Check RestoreApplicationData ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, UpdateHash()); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)).Times(0); + EXPECT_CALL(*mock_app_, UpdateHash()); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)).Times(0); - bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_FALSE(res); } @@ -223,15 +270,15 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) { test_application_files; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, UpdateHash()); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, UpdateHash()); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); for (uint32_t i = 0; i < count_of_files; ++i) { - EXPECT_CALL(*app_mock_, + EXPECT_CALL(*mock_app_, AddFile(CheckAppFile( true, true, @@ -239,7 +286,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) { static_cast<mobile_apis::FileType::eType>(file_types[i])))); } - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -261,27 +308,27 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubmenues) { test_application_submenues; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); for (uint32_t i = 0; i < count_of_submenues; ++i) { - EXPECT_CALL(*app_mock_, AddSubMenu(i, test_application_submenues[i])); + EXPECT_CALL(*mock_app_, AddSubMenu(i, test_application_submenues[i])); } smart_objects::SmartObjectList requests; - EXPECT_CALL(app_mngr_, GetNextHMICorrelationID()) + EXPECT_CALL(mock_app_mngr_, GetNextHMICorrelationID()) .WillRepeatedly(Return(kCorId_)); EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(), CreateAddSubMenuRequestToHMI(_, kCorId_)) .WillRepeatedly(Return(requests)); - EXPECT_CALL(*app_mock_, UpdateHash()); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + EXPECT_CALL(*mock_app_, UpdateHash()); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -302,17 +349,21 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) { saved_app[application_manager::strings::application_commands] = test_application_commands; - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); // Check RestoreApplicationData ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, UpdateHash()); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, UpdateHash()); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); + ON_CALL(*mock_app_, help_prompt_manager()) + .WillByDefault(ReturnRef(*mock_help_prompt_manager_)); for (uint32_t i = 0; i < count_of_commands; ++i) { - EXPECT_CALL(*app_mock_, AddCommand(i, test_application_commands[i])); + EXPECT_CALL(*mock_app_, AddCommand(i, test_application_commands[i])); + EXPECT_CALL(*mock_help_prompt_manager_, + OnVrCommandAdded(i, test_application_commands[i], true)); } smart_objects::SmartObjectList requests; @@ -320,7 +371,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) { CreateAddCommandRequestToHMI(_, _)) .WillRepeatedly(Return(requests)); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -354,17 +405,17 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) { application_choice_sets; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, UpdateHash()); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, UpdateHash()); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); for (uint32_t i = 0; i < count_of_choice_sets; ++i) { - EXPECT_CALL(*app_mock_, AddChoiceSet(i, application_choice_sets[i])); + EXPECT_CALL(*mock_app_, AddChoiceSet(i, application_choice_sets[i])); } smart_objects::SmartObjectList requests; @@ -372,7 +423,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) { CreateAddVRCommandRequestFromChoiceToHMI(_)) .WillRepeatedly(Return(requests)); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -386,22 +437,22 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGlobalProperties) { test_global_properties; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(), SendGlobalPropertiesToHMI(_)); - EXPECT_CALL(*app_mock_, load_global_properties(test_global_properties)); + EXPECT_CALL(*mock_app_, load_global_properties(test_global_properties)); - EXPECT_CALL(*app_mock_, UpdateHash()); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + EXPECT_CALL(*mock_app_, UpdateHash()); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -410,7 +461,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) { smart_objects::SmartObject test_subscriptions; smart_objects::SmartObject app_buttons; - uint32_t count_of_buttons = 17; + const uint32_t count_of_buttons = 17; for (uint32_t i = 0; i < count_of_buttons; ++i) { app_buttons[i] = i; } @@ -421,30 +472,37 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) { smart_objects::SmartObject saved_app; saved_app[application_manager::strings::hash_id] = kHash_; saved_app[application_manager::strings::grammar_id] = kTestGrammarId_; - saved_app[application_manager::strings::application_subscribtions] = + saved_app[application_manager::strings::application_subscriptions] = test_subscriptions; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); for (uint32_t i = 0; i < count_of_buttons; ++i) { EXPECT_CALL( - *app_mock_, + *mock_app_, SubscribeToButton(static_cast<mobile_apis::ButtonName::eType>(i))); } - EXPECT_CALL(*app_mock_, UpdateHash()); + EXPECT_CALL(*mock_app_, UpdateHash()); + + std::list<application_manager::AppExtensionPtr> extensions; + extensions.insert(extensions.begin(), mock_app_extension_); + + EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions)); + + EXPECT_CALL(*mock_app_extension_, ProcessResumption(test_subscriptions)); EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(), SendAllOnButtonSubscriptionNotificationsForApp(_, _)).Times(2); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -466,31 +524,30 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) { smart_objects::SmartObject saved_app; saved_app[application_manager::strings::hash_id] = kHash_; saved_app[application_manager::strings::grammar_id] = kTestGrammarId_; - saved_app[application_manager::strings::application_subscribtions] = + saved_app[application_manager::strings::application_subscriptions] = test_subscriptions; // Check RestoreApplicationData - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); - - for (size_t i = 0; i < app_vi.length(); ++i) { - EXPECT_CALL( - *app_mock_, - SubscribeToIVI(static_cast<mobile_apis::VehicleDataType::eType>(i))); - } + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); smart_objects::SmartObjectList requests; - EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(), - GetIVISubscriptionRequests(_)).WillRepeatedly(Return(requests)); - EXPECT_CALL(*app_mock_, UpdateHash()); - const bool res = res_ctrl_->StartResumption(app_mock_, kHash_); + EXPECT_CALL(*mock_app_, UpdateHash()); + std::list<application_manager::AppExtensionPtr> extensions; + + extensions.insert(extensions.begin(), mock_app_extension_); + + EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions)); + + EXPECT_CALL(*mock_app_extension_, ProcessResumption(test_subscriptions)); + const bool res = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(res); } @@ -505,43 +562,80 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToWayPoints) { ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_CALL(*app_mock_, set_grammar_id(kTestGrammarId_)); + EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_)); EXPECT_CALL( - app_mngr_, + mock_app_mngr_, SubscribeAppForWayPoints(A<application_manager::ApplicationSharedPtr>())); const mobile_apis::HMILevel::eType hmi_test_level = mobile_apis::HMILevel::HMI_FULL; - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(hmi_test_level)); - EXPECT_CALL(state_controller_, SetRegularState(_, hmi_test_level)); + EXPECT_CALL(mock_state_controller_, SetRegularState(_, hmi_test_level)); - const bool result = res_ctrl_->StartResumption(app_mock_, kHash_); + const bool result = res_ctrl_->StartResumption(mock_app_, kHash_); EXPECT_TRUE(result); } TEST_F(ResumeCtrlTest, StartResumptionOnlyHMILevel) { smart_objects::SmartObject saved_app; - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - const bool res = res_ctrl_->StartResumptionOnlyHMILevel(app_mock_); + const bool res = res_ctrl_->StartResumptionOnlyHMILevel(mock_app_); EXPECT_TRUE(res); } +TEST_F(ResumeCtrlTest, RetryResumption) { + const uint32_t app_id = 1; + + EXPECT_CALL(mock_app_mngr_, application(app_id)).WillOnce(Return(mock_app_)); + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .WillOnce(Return(eType::HMI_FULL)); + + res_ctrl_->RetryResumption(app_id); + + bool is_resumption_active = res_ctrl_->get_resumption_active(); + EXPECT_TRUE(is_resumption_active); +} + +TEST_F(ResumeCtrlTest, RetryResumption_NotDeferred) { + const uint32_t app_id = 1; + + EXPECT_CALL(mock_app_mngr_, application(app_id)).WillOnce(Return(mock_app_)); + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .WillOnce(Return(eType::INVALID_ENUM)); + + res_ctrl_->RetryResumption(app_id); + + bool is_resumption_active = res_ctrl_->get_resumption_active(); + EXPECT_FALSE(is_resumption_active); +} + TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInFull) { mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; uint32_t ign_off_count = 0; smart_objects::SmartObject saved_app; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; saved_app[application_manager::strings::ign_off_count] = ign_off_count; saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); - EXPECT_CALL(state_controller_, SetRegularState(_, restored_test_type)) + EXPECT_CALL(mock_state_controller_, SetRegularState(_, restored_test_type)) .Times(AtLeast(1)); GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); @@ -550,9 +644,9 @@ TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInFull) { RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) .WillOnce(Return(true)); - ON_CALL(app_mngr_, GetUserConsentForDevice("12345")) + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) .WillByDefault(Return(policy::kDeviceAllowed)); - res_ctrl_->StartAppHmiStateResumption(app_mock_); + res_ctrl_->StartAppHmiStateResumption(mock_app_); } TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInBackground) { @@ -563,13 +657,145 @@ TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInBackground) { saved_app[application_manager::strings::ign_off_count] = ign_off_count; saved_app[application_manager::strings::hmi_level] = restored_test_type; - EXPECT_CALL(app_mngr_, state_controller()).Times(0); + EXPECT_CALL(mock_app_mngr_, state_controller()).Times(0); + GetInfoFromApp(); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppHasDeferredResumption) { + mobile_apis::HMILevel::eType restored_test_type = eType::HMI_NONE; + mobile_apis::HMILevel::eType deferred_level = eType::HMI_FULL; + uint32_t ign_off_count = 0; + smart_objects::SmartObject saved_app; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; + saved_app[application_manager::strings::ign_off_count] = ign_off_count; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + // resume into deferred level instead of restored level + EXPECT_CALL(mock_state_controller_, SetRegularState(_, deferred_level)) + .Times(AtLeast(1)); + GetInfoFromApp(); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + mobile_apis::HMILevel::eType app_deferred_level = deferred_level; + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .WillRepeatedly(ReturnPointee(&app_deferred_level)); + EXPECT_CALL(*mock_app_, + set_deferred_resumption_hmi_level(eType::INVALID_ENUM)) + .WillOnce(SaveArg<0>(&app_deferred_level)); + + EXPECT_CALL(*mock_storage_, + RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) + .WillOnce(Return(true)); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F(ResumeCtrlTest, + StartAppHmiStateResumption_HighBandwidthTransportNotAvailable) { + mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; + uint32_t ign_off_count = 0; + smart_objects::SmartObject saved_app; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; + saved_app[application_manager::strings::ign_off_count] = ign_off_count; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + EXPECT_CALL(mock_state_controller_, SetRegularState(_, eType::HMI_LIMITED)) + .Times(AtLeast(1)); GetInfoFromApp(); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - res_ctrl_->StartAppHmiStateResumption(app_mock_); + EXPECT_CALL(mock_app_mngr_, CheckResumptionRequiredTransportAvailable(_)) + .WillOnce(Return(false)); + + EXPECT_CALL(*mock_app_, is_navi()).WillRepeatedly(Return(true)); + EXPECT_CALL(*mock_app_, mobile_projection_enabled()) + .WillRepeatedly(Return(false)); + EXPECT_CALL(*mock_app_, is_media_application()).WillRepeatedly(Return(false)); + + // if resumption is deferred ... + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .WillRepeatedly(Return(restored_test_type)); + + // ... then RemoveApplicationFromSaved() will not be called + EXPECT_CALL(*mock_storage_, + RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) + .Times(0); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F( + ResumeCtrlTest, + StartAppHmiStateResumption_HighBandwidthTransportNotAvailable_NaviAndMedia) { + mobile_apis::HMILevel::eType restored_test_type = eType::HMI_LIMITED; + uint32_t ign_off_count = 0; + smart_objects::SmartObject saved_app; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; + saved_app[application_manager::strings::ign_off_count] = ign_off_count; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + // in this test, it is expected that the app will resume into LIMITED, which + // is the higher level among NONE and LIMITED + EXPECT_CALL(mock_state_controller_, SetRegularState(_, eType::HMI_LIMITED)) + .Times(AtLeast(1)); + GetInfoFromApp(); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + EXPECT_CALL(mock_app_mngr_, CheckResumptionRequiredTransportAvailable(_)) + .WillOnce(Return(false)); + + EXPECT_CALL(*mock_app_, is_navi()).WillRepeatedly(Return(true)); + EXPECT_CALL(*mock_app_, mobile_projection_enabled()) + .WillRepeatedly(Return(false)); + EXPECT_CALL(*mock_app_, is_media_application()).WillRepeatedly(Return(true)); + + std::string navi_lowbandwidth_level("NONE"); + std::string projection_lowbandwidth_level("BACKGROUND"); + std::string media_lowbandwidth_level("LIMITED"); + EXPECT_CALL(mock_application_manager_settings_, + navigation_lowbandwidth_resumption_level()) + .WillRepeatedly(ReturnRef(navi_lowbandwidth_level)); + EXPECT_CALL(mock_application_manager_settings_, + projection_lowbandwidth_resumption_level()) + .WillRepeatedly(ReturnRef(projection_lowbandwidth_level)); + EXPECT_CALL(mock_application_manager_settings_, + media_lowbandwidth_resumption_level()) + .WillRepeatedly(ReturnRef(media_lowbandwidth_level)); + + EXPECT_CALL(*mock_app_, deferred_resumption_hmi_level()) + .WillRepeatedly(Return(restored_test_type)); + + EXPECT_CALL(*mock_storage_, + RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) + .Times(0); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + res_ctrl_->StartAppHmiStateResumption(mock_app_); } /** @@ -579,23 +805,30 @@ TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInBackground) { TEST_F(ResumeCtrlTest, RestoreAppHMIState_RestoreHMILevelFull) { mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; + ::application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + smart_objects::SmartObject saved_app; saved_app[application_manager::strings::hash_id] = kHash_; saved_app[application_manager::strings::grammar_id] = kTestGrammarId_; saved_app[application_manager::strings::hmi_level] = restored_test_type; - EXPECT_CALL(state_controller_, SetRegularState(_, restored_test_type)) + EXPECT_CALL(mock_state_controller_, SetRegularState(_, restored_test_type)) .Times(AtLeast(1)); GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - ON_CALL(app_mngr_, GetUserConsentForDevice("12345")) + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) .WillByDefault(Return(policy::kDeviceAllowed)); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); + EXPECT_CALL(*mock_app_, set_is_resuming(true)); - const bool res = res_ctrl_->RestoreAppHMIState(app_mock_); + const bool res = res_ctrl_->RestoreAppHMIState(mock_app_); EXPECT_TRUE(res); } @@ -604,35 +837,76 @@ TEST_F(ResumeCtrlTest, SetupDefaultHMILevel) { saved_app[application_manager::strings::hmi_level] = kDefaultTestLevel_; - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); GetInfoFromApp(); - EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0); + EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0); - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); - EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_)) + EXPECT_CALL(mock_state_controller_, SetRegularState(_, kDefaultTestLevel_)) .Times(AtLeast(1)); - res_ctrl_->SetupDefaultHMILevel(app_mock_); + res_ctrl_->SetupDefaultHMILevel(mock_app_); +} + +TEST_F(ResumeCtrlTest, + SetupDefaultHMILevel_HighBandwidthTransportNotAvailable) { + smart_objects::SmartObject saved_app; + + saved_app[application_manager::strings::hmi_level] = kDefaultTestLevel_; + + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillByDefault(Return(kDefaultTestLevel_)); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0); + + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillByDefault(Return(kDefaultTestLevel_)); + + EXPECT_CALL(mock_app_mngr_, CheckResumptionRequiredTransportAvailable(_)) + .WillRepeatedly(Return(false)); + + EXPECT_CALL(*mock_app_, is_navi()).WillRepeatedly(Return(false)); + EXPECT_CALL(*mock_app_, mobile_projection_enabled()) + .WillRepeatedly(Return(true)); + EXPECT_CALL(*mock_app_, is_media_application()).WillRepeatedly(Return(false)); + + // SetRegularState() should be called with kProjectionLowbandwidthLevel_ + EXPECT_CALL(mock_state_controller_, SetRegularState(_, eType::HMI_NONE)) + .Times(AtLeast(1)); + + res_ctrl_->SetupDefaultHMILevel(mock_app_); } TEST_F(ResumeCtrlTest, ApplicationResumptiOnTimer_AppInFull) { - ON_CALL(app_mngr_, application(kTestAppId_)).WillByDefault(Return(app_mock_)); + ON_CALL(mock_app_mngr_, application(kTestAppId_)) + .WillByDefault(Return(mock_app_)); + + ::application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; const uint32_t ign_off_count = 0u; smart_objects::SmartObject saved_app; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; saved_app[application_manager::strings::ign_off_count] = ign_off_count; saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; MockStateController state_controller; - EXPECT_CALL(app_mngr_, state_controller()) + EXPECT_CALL(mock_app_mngr_, state_controller()) .WillOnce(ReturnRef(state_controller)); EXPECT_CALL(state_controller, SetRegularState(_, restored_test_type)) .Times(AtLeast(1)); GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); @@ -641,37 +915,37 @@ TEST_F(ResumeCtrlTest, ApplicationResumptiOnTimer_AppInFull) { RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) .WillOnce(Return(true)); - ON_CALL(app_mngr_, GetUserConsentForDevice(kMacAddress_)) + ON_CALL(mock_app_mngr_, GetUserConsentForDevice(kMacAddress_)) .WillByDefault(Return(policy::kDeviceAllowed)); - res_ctrl_->StartAppHmiStateResumption(app_mock_); + res_ctrl_->StartAppHmiStateResumption(mock_app_); } /** * @brief group of tests which check correct SetAppHMIState -*/ + */ TEST_F(ResumeCtrlTest, SetAppHMIState_HMINone_WithoutCheckPolicy) { GetInfoFromApp(); - EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0); + EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); - EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_)) + EXPECT_CALL(*mock_app_, set_is_resuming(true)); + EXPECT_CALL(mock_state_controller_, SetRegularState(_, kDefaultTestLevel_)) .Times(AtLeast(1)); const bool res = - res_ctrl_->SetAppHMIState(app_mock_, kDefaultTestLevel_, false); + res_ctrl_->SetAppHMIState(mock_app_, kDefaultTestLevel_, false); EXPECT_TRUE(res); } TEST_F(ResumeCtrlTest, SetAppHMIState_HMILimited_WithoutCheckPolicy) { mobile_apis::HMILevel::eType test_type = eType::HMI_LIMITED; GetInfoFromApp(); - EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0); + EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); - EXPECT_CALL(state_controller_, SetRegularState(_, test_type)) + EXPECT_CALL(*mock_app_, set_is_resuming(true)); + EXPECT_CALL(mock_state_controller_, SetRegularState(_, test_type)) .Times(AtLeast(1)); - const bool res = res_ctrl_->SetAppHMIState(app_mock_, test_type, false); + const bool res = res_ctrl_->SetAppHMIState(mock_app_, test_type, false); EXPECT_TRUE(res); } @@ -679,14 +953,14 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithoutCheckPolicy) { mobile_apis::HMILevel::eType test_type = eType::HMI_FULL; GetInfoFromApp(); // GetDefaultHmiLevel should not be called - EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)).Times(0); - EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)).Times(0); + EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); - EXPECT_CALL(state_controller_, SetRegularState(_, test_type)) + EXPECT_CALL(*mock_app_, set_is_resuming(true)); + EXPECT_CALL(mock_state_controller_, SetRegularState(_, test_type)) .Times(AtLeast(1)); - const bool res = res_ctrl_->SetAppHMIState(app_mock_, test_type, false); + const bool res = res_ctrl_->SetAppHMIState(mock_app_, test_type, false); EXPECT_TRUE(res); } @@ -694,14 +968,14 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevAllowed) { mobile_apis::HMILevel::eType test_type = eType::HMI_FULL; GetInfoFromApp(); - ON_CALL(app_mngr_, GetUserConsentForDevice("12345")) + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) .WillByDefault(Return(policy::kDeviceAllowed)); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); - EXPECT_CALL(state_controller_, SetRegularState(_, test_type)) + EXPECT_CALL(*mock_app_, set_is_resuming(true)); + EXPECT_CALL(mock_state_controller_, SetRegularState(_, test_type)) .Times(AtLeast(1)); - const bool res = res_ctrl_->SetAppHMIState(app_mock_, test_type, true); + const bool res = res_ctrl_->SetAppHMIState(mock_app_, test_type, true); EXPECT_TRUE(res); } @@ -709,51 +983,51 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevDisallowed) { mobile_apis::HMILevel::eType test_type = eType::HMI_FULL; GetInfoFromApp(); - ON_CALL(app_mngr_, GetUserConsentForDevice("12345")) + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) .WillByDefault(Return(policy::kDeviceDisallowed)); - EXPECT_CALL(*app_mock_, set_is_resuming(true)); - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + EXPECT_CALL(*mock_app_, set_is_resuming(true)); + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); - EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_)) + EXPECT_CALL(mock_state_controller_, SetRegularState(_, kDefaultTestLevel_)) .Times(AtLeast(1)); - const bool res = res_ctrl_->SetAppHMIState(app_mock_, test_type, true); + const bool res = res_ctrl_->SetAppHMIState(mock_app_, test_type, true); EXPECT_FALSE(res); } TEST_F(ResumeCtrlTest, SaveAllApplications) { - utils::SharedPtr<application_manager_test::MockApplication> test_app = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager_test::MockApplication> test_app = + std::make_shared<application_manager_test::MockApplication>(); EXPECT_CALL(*test_app, app_id()).WillRepeatedly(Return(kTestAppId_)); application_manager::ApplicationSet app_set; app_set.insert(test_app); DataAccessor<application_manager::ApplicationSet> accessor(app_set, - app_set_lock_); + app_set_lock_ptr_); - ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor)); + ON_CALL(mock_app_mngr_, applications()).WillByDefault(Return(accessor)); EXPECT_CALL(*mock_storage_, SaveApplication(Eq(test_app))); res_ctrl_->SaveAllApplications(); } TEST_F(ResumeCtrlTest, SaveAllApplications_EmptyApplicationlist) { - utils::SharedPtr<application_manager::Application> mock_app = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager::Application> mock_app = + std::make_shared<application_manager_test::MockApplication>(); application_manager::ApplicationSet app_set; DataAccessor<application_manager::ApplicationSet> accessor(app_set, - app_set_lock_); + app_set_lock_ptr_); - ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor)); + ON_CALL(mock_app_mngr_, applications()).WillByDefault(Return(accessor)); EXPECT_CALL(*mock_storage_, SaveApplication(mock_app)).Times(0); res_ctrl_->SaveAllApplications(); } TEST_F(ResumeCtrlTest, SaveApplication) { - utils::SharedPtr<application_manager::Application> app_sh_mock = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager::Application> app_sh_mock = + std::make_shared<application_manager_test::MockApplication>(); EXPECT_CALL(*mock_storage_, SaveApplication(app_sh_mock)); res_ctrl_->SaveApplication(app_sh_mock); @@ -763,26 +1037,26 @@ TEST_F(ResumeCtrlTest, OnAppActivated_ResumptionHasStarted) { smart_objects::SmartObject saved_app; GetInfoFromApp(); - ON_CALL(app_mngr_, GetDefaultHmiLevel(const_app_)) + ON_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) .WillByDefault(Return(kDefaultTestLevel_)); ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - ON_CALL(*app_mock_, app_id()).WillByDefault(Return(kTestAppId_)); + ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kTestAppId_)); - const bool res = res_ctrl_->StartResumptionOnlyHMILevel(app_mock_); + const bool res = res_ctrl_->StartResumptionOnlyHMILevel(mock_app_); EXPECT_TRUE(res); - utils::SharedPtr<application_manager_test::MockApplication> app_sh_mock = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager_test::MockApplication> app_sh_mock = + std::make_shared<application_manager_test::MockApplication>(); EXPECT_CALL(*app_sh_mock, app_id()).WillOnce(Return(kTestAppId_)); res_ctrl_->OnAppActivated(app_sh_mock); } TEST_F(ResumeCtrlTest, OnAppActivated_ResumptionNotActive) { - utils::SharedPtr<application_manager_test::MockApplication> app_sh_mock = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager_test::MockApplication> app_sh_mock = + std::make_shared<application_manager_test::MockApplication>(); EXPECT_CALL(*app_sh_mock, app_id()).Times(0); res_ctrl_->OnAppActivated(app_sh_mock); } @@ -840,7 +1114,7 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFiles_WithoutCommandAndChoiceSets) { GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(app_mock_)); + EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(mock_app_)); } TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithCommands) { @@ -861,7 +1135,7 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithCommands) { VerifyImageFiles(_, _, _)) .WillRepeatedly(Return(mobile_apis::Result::SUCCESS)); - EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(app_mock_)); + EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(mock_app_)); } TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithChoiceSet) { @@ -878,7 +1152,7 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithChoiceSet) { GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(app_mock_)); + EXPECT_TRUE(res_ctrl_->CheckPersistenceFilesForResumption(mock_app_)); } // TODO (VVeremjova) APPLINK-16718 @@ -888,15 +1162,15 @@ TEST_F(ResumeCtrlTest, DISABLED_OnSuspend) { } TEST_F(ResumeCtrlTest, OnSuspend_EmptyApplicationlist) { - utils::SharedPtr<application_manager::Application> mock_app = - ::utils::MakeShared<application_manager_test::MockApplication>(); + std::shared_ptr<application_manager::Application> mock_app = + std::make_shared<application_manager_test::MockApplication>(); application_manager::ApplicationSet app_set; DataAccessor<application_manager::ApplicationSet> accessor(app_set, - app_set_lock_); + app_set_lock_ptr_); - ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor)); + ON_CALL(mock_app_mngr_, applications()).WillByDefault(Return(accessor)); EXPECT_CALL(*mock_storage_, SaveApplication(mock_app)).Times(0); EXPECT_CALL(*mock_storage_, IncrementIgnOffCount()).Times(0); @@ -918,7 +1192,7 @@ TEST_F(ResumeCtrlTest, RemoveApplicationFromSaved) { EXPECT_CALL(*mock_storage_, RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) .WillOnce(Return(true)); - EXPECT_TRUE(res_ctrl_->RemoveApplicationFromSaved(app_mock_)); + EXPECT_TRUE(res_ctrl_->RemoveApplicationFromSaved(mock_app_)); } TEST_F(ResumeCtrlTest, CheckApplicationkHash_) { @@ -929,7 +1203,7 @@ TEST_F(ResumeCtrlTest, CheckApplicationkHash_) { ON_CALL(*mock_storage_, GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); - EXPECT_TRUE(res_ctrl_->CheckApplicationHash(app_mock_, kHash_)); + EXPECT_TRUE(res_ctrl_->CheckApplicationHash(mock_app_, kHash_)); } TEST_F(ResumeCtrlTest, GetSavedAppHmiLevel_NoAskedApp_INVALID_ENUM) { @@ -955,6 +1229,194 @@ TEST_F(ResumeCtrlTest, GetSavedAppHmiLevel_AskedAppFound_INVALID_ENUM) { res_ctrl_->GetSavedAppHmiLevel(kTestPolicyAppId_, kMacAddress_)); } +TEST_F( + ResumeCtrlTest, + ResumptionLowVoltage_AppInFullUnregisteredWithinTimeFrame_HMILevelRestored) { + const mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; + smart_objects::SmartObject saved_app; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + + EXPECT_CALL(mock_state_controller_, SetRegularState(_, restored_test_type)) + .Times(AtLeast(1)); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + EXPECT_CALL(*mock_storage_, + RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) + .WillOnce(Return(true)); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + + NiceMock<MockApplicationManagerSettings> app_mngr_settings_; + EXPECT_CALL(mock_app_mngr_, get_settings()) + .WillOnce(ReturnRef(app_mngr_settings_)); + + EXPECT_CALL(app_mngr_settings_, resumption_delay_before_ign()) + .WillOnce(Return(resumption_delay_before_ign_)); + + res_ctrl_->SaveLowVoltageTime(); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F( + ResumeCtrlTest, + ResumptionLowVoltage_AppInFullUnregisteredBeyondTimeFrame_HMILevelNotRestored) { + const mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ - time_offset; + smart_objects::SmartObject saved_app; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + + EXPECT_CALL(mock_app_mngr_, state_controller()).Times(0); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + + NiceMock<MockApplicationManagerSettings> app_mngr_settings_; + EXPECT_CALL(mock_app_mngr_, get_settings()) + .WillOnce(ReturnRef(app_mngr_settings_)); + + EXPECT_CALL(app_mngr_settings_, resumption_delay_before_ign()) + .WillOnce(Return(resumption_delay_before_ign_)); + + res_ctrl_->SaveLowVoltageTime(); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F(ResumeCtrlTest, ResumptionLowVoltage_AppInBackground_NotRestored) { + const mobile_apis::HMILevel::eType restored_test_type = eType::HMI_BACKGROUND; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ - time_offset; + smart_objects::SmartObject saved_app; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + + EXPECT_CALL(mock_app_mngr_, state_controller()).Times(0); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + res_ctrl_->SaveLowVoltageTime(); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F( + ResumeCtrlTest, + ResumptionLowVoltage_AppInLimitedlUnregisteredWithinTimeFrame_HMILevelRestored) { + const mobile_apis::HMILevel::eType restored_test_type = eType::HMI_LIMITED; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ + time_offset; + smart_objects::SmartObject saved_app; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + + EXPECT_CALL(mock_state_controller_, SetRegularState(_, restored_test_type)) + .Times(AtLeast(1)); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + EXPECT_CALL(*mock_storage_, + RemoveApplicationFromSaved(kTestPolicyAppId_, kMacAddress_)) + .WillOnce(Return(true)); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + + NiceMock<MockApplicationManagerSettings> app_mngr_settings_; + EXPECT_CALL(mock_app_mngr_, get_settings()) + .WillOnce(ReturnRef(app_mngr_settings_)); + + EXPECT_CALL(app_mngr_settings_, resumption_delay_before_ign()) + .WillOnce(Return(resumption_delay_before_ign_ + time_offset)); + + res_ctrl_->SaveLowVoltageTime(); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + +TEST_F( + ResumeCtrlTest, + ResumptionLowVoltage_AppInLimitedlUnregisteredBeyondTimeFrame_HMILevelNotRestored) { + const mobile_apis::HMILevel::eType restored_test_type = eType::HMI_LIMITED; + const uint32_t time_offset = 5; + const uint32_t time_stamp = + time(nullptr) - resumption_delay_before_ign_ - time_offset; + smart_objects::SmartObject saved_app; + saved_app[application_manager::strings::hmi_level] = restored_test_type; + saved_app[application_manager::strings::time_stamp] = time_stamp; + + application_manager::CommandsMap command; + DataAccessor<application_manager::CommandsMap> data_accessor( + command, app_set_lock_ptr_); + + EXPECT_CALL(mock_app_mngr_, state_controller()).Times(0); + GetInfoFromApp(); + EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(const_app_)) + .WillRepeatedly(Return(kDefaultTestLevel_)); + EXPECT_CALL(*mock_app_, commands_map()).WillRepeatedly(Return(data_accessor)); + ON_CALL(*mock_storage_, + GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _)) + .WillByDefault(DoAll(SetArgReferee<2>(saved_app), Return(true))); + + ON_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")) + .WillByDefault(Return(policy::kDeviceAllowed)); + + NiceMock<MockApplicationManagerSettings> app_mngr_settings_; + EXPECT_CALL(mock_app_mngr_, get_settings()) + .WillOnce(ReturnRef(app_mngr_settings_)); + + EXPECT_CALL(app_mngr_settings_, resumption_delay_before_ign()) + .WillOnce(Return(resumption_delay_before_ign_)); + + res_ctrl_->SaveLowVoltageTime(); + res_ctrl_->StartAppHmiStateResumption(mock_app_); +} + } // namespace resumption_test } // namespace components } // namespace test diff --git a/src/components/application_manager/test/resumption/resumption_data_db_test.cc b/src/components/application_manager/test/resumption/resumption_data_db_test.cc index cf0ebb7fd2..8423520b9f 100644 --- a/src/components/application_manager/test/resumption/resumption_data_db_test.cc +++ b/src/components/application_manager/test/resumption/resumption_data_db_test.cc @@ -38,7 +38,7 @@ #include "interfaces/MOBILE_API.h" #include "utils/sqlite_wrapper/sql_database.h" #include "utils/sqlite_wrapper/sql_query.h" -#include "utils/make_shared.h" + #include "utils/file_system.h" #include "application_manager/resumption_data_test.h" #include "application_manager/test_resumption_data_db.h" @@ -52,6 +52,7 @@ namespace resumption_test { using ::testing::NiceMock; using ::testing::ReturnRef; +using ::testing::_; using application_manager_test::MockApplication; namespace am = application_manager; @@ -67,7 +68,7 @@ const std::string kPath = class ResumptionDataDBTest : public ResumptionDataTest { protected: void SetUp() OVERRIDE { - app_mock = utils::MakeShared<NiceMock<MockApplication> >(); + app_mock = std::make_shared<NiceMock<MockApplication> >(); policy_app_id_ = "test_policy_app_id"; app_id_ = 10; is_audio_ = true; @@ -122,7 +123,7 @@ class ResumptionDataDBTest : public ResumptionDataTest { void SetZeroIgnOffTime() { utils::dbms::SQLQuery query(test_db()); - EXPECT_TRUE(query.Prepare(KUpdateLastIgnOffTime)); + EXPECT_TRUE(query.Prepare(kUpdateLastIgnOffTime)); query.Bind(0, 0); EXPECT_TRUE(query.Exec()); } @@ -165,7 +166,7 @@ class ResumptionDataDBTest : public ResumptionDataTest { "DELETE FROM `applicationCommandsArray`; " "DELETE FROM `applicationFilesArray`; " "DELETE FROM `applicationSubMenuArray`; " - "DELETE FROM `applicationSubscribtionsArray`; " + "DELETE FROM `applicationSubscriptionsArray`; " "DELETE FROM `_internal_data`; "; private: @@ -271,6 +272,10 @@ void ResumptionDataDBTest::CheckGlobalProportiesData() { select_image.GetInteger(0)); EXPECT_EQ((*menu_icon_)[am::strings::value].asString(), select_image.GetString(1)); + if ((*menu_icon_).keyExists(am::strings::is_template)) { + EXPECT_EQ((*menu_icon_)[am::strings::is_template].asBool(), + select_image.GetBoolean(2)); + } } if (!select_globalproperties.IsNull(8)) { utils::dbms::SQLQuery select_tts_chunk(test_db()); @@ -559,6 +564,7 @@ TEST_F(ResumptionDataDBTest, Init) { TEST_F(ResumptionDataDBTest, SaveApplication) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); } @@ -566,6 +572,7 @@ TEST_F(ResumptionDataDBTest, SaveApplication) { TEST_F(ResumptionDataDBTest, RemoveApplicationFromSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); EXPECT_TRUE( @@ -580,6 +587,7 @@ TEST_F(ResumptionDataDBTest, RemoveApplicationFromSaved) { TEST_F(ResumptionDataDBTest, RemoveApplicationFromSaved_AppNotSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); sm::SmartObject saved_app; @@ -591,6 +599,7 @@ TEST_F(ResumptionDataDBTest, RemoveApplicationFromSaved_AppNotSaved) { TEST_F(ResumptionDataDBTest, SavedApplicationTwice) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)).Times(2); res_db()->SaveApplication(app_mock); CheckSavedDB(); res_db()->SaveApplication(app_mock); @@ -600,6 +609,7 @@ TEST_F(ResumptionDataDBTest, SavedApplicationTwice) { TEST_F(ResumptionDataDBTest, SavedApplicationTwice_UpdateApp) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)).Times(2); res_db()->SaveApplication(app_mock); CheckSavedDB(); (*vr_help_)[0][am::strings::position] = 2; @@ -611,6 +621,7 @@ TEST_F(ResumptionDataDBTest, SavedApplicationTwice_UpdateApp) { TEST_F(ResumptionDataDBTest, IsApplicationSaved_ApplicationSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); ssize_t result = res_db()->IsApplicationSaved(policy_app_id_, kMacAddress_); EXPECT_EQ(0, result); @@ -619,6 +630,7 @@ TEST_F(ResumptionDataDBTest, IsApplicationSaved_ApplicationSaved) { TEST_F(ResumptionDataDBTest, IsApplicationSaved_ApplicationRemoved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); EXPECT_TRUE( res_db()->RemoveApplicationFromSaved(policy_app_id_, kMacAddress_)); @@ -629,6 +641,7 @@ TEST_F(ResumptionDataDBTest, IsApplicationSaved_ApplicationRemoved) { TEST_F(ResumptionDataDBTest, GetSavedApplication) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -650,6 +663,7 @@ TEST_F(ResumptionDataDBTest, GetSavedApplication_AppNotSaved) { TEST_F(ResumptionDataDBTest, GetDataForLoadResumeData) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); sm::SmartObject saved_app; @@ -668,6 +682,7 @@ TEST_F(ResumptionDataDBTest, GetDataForLoadResumeData_AppRemove) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); EXPECT_TRUE( @@ -679,6 +694,7 @@ TEST_F(ResumptionDataDBTest, GetDataForLoadResumeData_AppRemove) { TEST_F(ResumptionDataDBTest, UpdateHmiLevel) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); HMILevel::eType new_hmi_level = HMILevel::HMI_LIMITED; @@ -690,6 +706,7 @@ TEST_F(ResumptionDataDBTest, UpdateHmiLevel) { TEST_F(ResumptionDataDBTest, IsHMIApplicationIdExist_AppIsSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); EXPECT_TRUE(res_db()->IsHMIApplicationIdExist(hmi_app_id_)); @@ -698,6 +715,7 @@ TEST_F(ResumptionDataDBTest, IsHMIApplicationIdExist_AppIsSaved) { TEST_F(ResumptionDataDBTest, IsHMIApplicationIdExist_AppNotSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); uint32_t new_hmi_app_id_ = hmi_app_id_ + 10; @@ -707,6 +725,7 @@ TEST_F(ResumptionDataDBTest, IsHMIApplicationIdExist_AppNotSaved) { TEST_F(ResumptionDataDBTest, GetHMIApplicationID) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); EXPECT_EQ(hmi_app_id_, @@ -716,6 +735,7 @@ TEST_F(ResumptionDataDBTest, GetHMIApplicationID) { TEST_F(ResumptionDataDBTest, GetHMIApplicationID_AppNotSaved) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); EXPECT_EQ(0u, res_db()->GetHMIApplicationID(policy_app_id_, "other_dev_id")); @@ -725,6 +745,7 @@ TEST_F(ResumptionDataDBTest, OnSuspend) { PrepareData(); EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -737,6 +758,7 @@ TEST_F(ResumptionDataDBTest, OnSuspendFourTimes) { PrepareData(); EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -762,6 +784,7 @@ TEST_F(ResumptionDataDBTest, OnSuspendOnAwake) { EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -779,6 +802,7 @@ TEST_F(ResumptionDataDBTest, Awake_AppNotSuspended) { EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -792,6 +816,7 @@ TEST_F(ResumptionDataDBTest, TwiceAwake_AppNotSuspended) { EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); CheckSavedDB(); @@ -808,6 +833,7 @@ TEST_F(ResumptionDataDBTest, GetHashId) { PrepareData(); EXPECT_TRUE(res_db()->Init()); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); std::string test_hash; @@ -821,6 +847,7 @@ TEST_F(ResumptionDataDBTest, GetIgnOffTime_AfterSuspendAndAwake) { SetZeroIgnOffTime(); uint32_t last_ign_off_time; + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); last_ign_off_time = res_db()->GetIgnOffTime(); @@ -844,6 +871,7 @@ TEST_F(ResumptionDataDBTest, DropAppResumptionData) { EXPECT_TRUE(res_db()->Init()); SetZeroIgnOffTime(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_db()->SaveApplication(app_mock); EXPECT_TRUE(res_db()->DropAppDataResumption(kMacAddress_, policy_app_id_)); @@ -863,8 +891,8 @@ TEST_F(ResumptionDataDBTest, DropAppResumptionData) { EXPECT_TRUE(app.keyExists(am::strings::application_global_properties) && app[am::strings::application_global_properties].empty()); - EXPECT_TRUE(app.keyExists(am::strings::application_subscribtions) && - app[am::strings::application_subscribtions].empty()); + EXPECT_TRUE(app.keyExists(am::strings::application_subscriptions) && + app[am::strings::application_subscriptions].empty()); EXPECT_TRUE(app.keyExists(am::strings::application_files) && app[am::strings::application_files].empty()); diff --git a/src/components/application_manager/test/resumption/resumption_data_json_test.cc b/src/components/application_manager/test/resumption/resumption_data_json_test.cc index e017c39497..d049d0f541 100644 --- a/src/components/application_manager/test/resumption/resumption_data_json_test.cc +++ b/src/components/application_manager/test/resumption/resumption_data_json_test.cc @@ -52,6 +52,7 @@ namespace resumption_test { using ::testing::_; using ::testing::Return; +using ::testing::ReturnRef; using ::testing::NiceMock; namespace am = application_manager; @@ -68,7 +69,8 @@ class ResumptionDataJsonTest : public ResumptionDataTest { : last_state_("app_storage_folder", "app_info_storage") , res_json(last_state_, mock_application_manager_) {} virtual void SetUp() { - app_mock = new NiceMock<application_manager_test::MockApplication>(); + app_mock = std::make_shared< + NiceMock<application_manager_test::MockApplication> >(); policy_app_id_ = "test_policy_app_id"; app_id_ = 10; @@ -109,12 +111,14 @@ class ResumptionDataJsonTest : public ResumptionDataTest { TEST_F(ResumptionDataJsonTest, SaveApplication) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); } TEST_F(ResumptionDataJsonTest, SavedApplicationTwice) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)).Times(2); res_json.SaveApplication(app_mock); CheckSavedJson(); res_json.SaveApplication(app_mock); @@ -123,6 +127,7 @@ TEST_F(ResumptionDataJsonTest, SavedApplicationTwice) { TEST_F(ResumptionDataJsonTest, SavedApplicationTwice_UpdateApp) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)).Times(2); res_json.SaveApplication(app_mock); CheckSavedJson(); (*vr_help_)[0][am::strings::position] = 2; @@ -133,6 +138,7 @@ TEST_F(ResumptionDataJsonTest, SavedApplicationTwice_UpdateApp) { TEST_F(ResumptionDataJsonTest, RemoveApplicationFromSaved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); EXPECT_TRUE( res_json.RemoveApplicationFromSaved(policy_app_id_, kMacAddress_)); @@ -150,6 +156,7 @@ TEST_F(ResumptionDataJsonTest, RemoveApplicationFromSaved_AppNotSaved) { TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationSaved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); ssize_t result = res_json.IsApplicationSaved(policy_app_id_, kMacAddress_); @@ -158,6 +165,7 @@ TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationSaved) { TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationRemoved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); EXPECT_TRUE( @@ -168,6 +176,7 @@ TEST_F(ResumptionDataJsonTest, IsApplicationSaved_ApplicationRemoved) { TEST_F(ResumptionDataJsonTest, GetSavedApplication) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); smart_objects::SmartObject saved_app; EXPECT_TRUE( @@ -184,6 +193,7 @@ TEST_F(ResumptionDataJsonTest, GetSavedApplication_AppNotSaved) { TEST_F(ResumptionDataJsonTest, GetDataForLoadResumeData) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); smart_objects::SmartObject saved_app; @@ -201,6 +211,7 @@ TEST_F(ResumptionDataJsonTest, GetDataForLoadResumeData_AppRemove) { smart_objects::SmartObject saved_app; PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); EXPECT_TRUE( @@ -211,6 +222,7 @@ TEST_F(ResumptionDataJsonTest, GetDataForLoadResumeData_AppRemove) { TEST_F(ResumptionDataJsonTest, UpdateHmiLevel) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); HMILevel::eType new_hmi_level = HMILevel::HMI_LIMITED; @@ -222,6 +234,7 @@ TEST_F(ResumptionDataJsonTest, UpdateHmiLevel) { TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppIsSaved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); EXPECT_TRUE(res_json.IsHMIApplicationIdExist(hmi_app_id_)); @@ -229,6 +242,7 @@ TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppIsSaved) { TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppNotSaved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -238,6 +252,7 @@ TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppNotSaved) { TEST_F(ResumptionDataJsonTest, GetHMIApplicationID) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); EXPECT_EQ(hmi_app_id_, @@ -246,6 +261,7 @@ TEST_F(ResumptionDataJsonTest, GetHMIApplicationID) { TEST_F(ResumptionDataJsonTest, GetHMIApplicationID_AppNotSaved) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); EXPECT_EQ(0u, res_json.GetHMIApplicationID(policy_app_id_, "other_dev_id")); } @@ -253,7 +269,7 @@ TEST_F(ResumptionDataJsonTest, GetHMIApplicationID_AppNotSaved) { TEST_F(ResumptionDataJsonTest, OnSuspend) { SetZeroIgnOff(); PrepareData(); - + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -265,6 +281,7 @@ TEST_F(ResumptionDataJsonTest, OnSuspend) { TEST_F(ResumptionDataJsonTest, OnSuspendFourTimes) { PrepareData(); SetZeroIgnOff(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -282,6 +299,7 @@ TEST_F(ResumptionDataJsonTest, OnSuspendFourTimes) { TEST_F(ResumptionDataJsonTest, OnSuspendOnAwake) { PrepareData(); SetZeroIgnOff(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -297,6 +315,7 @@ TEST_F(ResumptionDataJsonTest, OnSuspendOnAwake) { TEST_F(ResumptionDataJsonTest, Awake_AppNotSuspended) { SetZeroIgnOff(); PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -308,6 +327,7 @@ TEST_F(ResumptionDataJsonTest, Awake_AppNotSuspended) { TEST_F(ResumptionDataJsonTest, TwiceAwake_AppNotSuspended) { SetZeroIgnOff(); PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -322,6 +342,7 @@ TEST_F(ResumptionDataJsonTest, TwiceAwake_AppNotSuspended) { TEST_F(ResumptionDataJsonTest, GetHashId) { PrepareData(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -334,6 +355,7 @@ TEST_F(ResumptionDataJsonTest, GetIgnOffTime_AfterSuspendAndAwake) { uint32_t last_ign_off_time; PrepareData(); SetZeroIgnOff(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); last_ign_off_time = res_json.GetIgnOffTime(); @@ -355,6 +377,7 @@ TEST_F(ResumptionDataJsonTest, GetIgnOffTime_AfterSuspendAndAwake) { TEST_F(ResumptionDataJsonTest, DropAppDataResumption) { PrepareData(); SetZeroIgnOff(); + EXPECT_CALL(*mock_app_extension_, SaveResumptionData(_)); res_json.SaveApplication(app_mock); CheckSavedJson(); @@ -375,8 +398,8 @@ TEST_F(ResumptionDataJsonTest, DropAppDataResumption) { EXPECT_TRUE(app.keyExists(am::strings::application_global_properties) && app[am::strings::application_global_properties].empty()); - EXPECT_TRUE(app.keyExists(am::strings::application_subscribtions) && - app[am::strings::application_subscribtions].empty()); + EXPECT_TRUE(app.keyExists(am::strings::application_subscriptions) && + app[am::strings::application_subscriptions].empty()); EXPECT_TRUE(app.keyExists(am::strings::application_files) && app[am::strings::application_files].empty()); diff --git a/src/components/application_manager/test/resumption/resumption_data_test.cc b/src/components/application_manager/test/resumption/resumption_data_test.cc index 1f13ff78f3..5658ab8535 100644 --- a/src/components/application_manager/test/resumption/resumption_data_test.cc +++ b/src/components/application_manager/test/resumption/resumption_data_test.cc @@ -50,6 +50,7 @@ namespace custom_str = utils::custom_string; using ::testing::Return; using ::testing::ReturnRef; using ::testing::ReturnPointee; +using ::testing::_; void ResumptionDataTest::CheckSavedApp(sm::SmartObject& resume_app_list) { EXPECT_EQ(policy_app_id_, resume_app_list[am::strings::app_id].asString()); @@ -72,7 +73,7 @@ void ResumptionDataTest::CheckSavedApp(sm::SmartObject& resume_app_list) { CheckGlobalProporties( resume_app_list[am::strings::application_global_properties]); - CheckSubscriptions(resume_app_list[am::strings::application_subscribtions]); + CheckSubscriptions(resume_app_list[am::strings::application_subscriptions]); } void ResumptionDataTest::CheckCommands(sm::SmartObject& res_list) { @@ -137,8 +138,6 @@ void ResumptionDataTest::CheckSubscriptions(sm::SmartObject& res_list) { res_list[am::strings::application_buttons][0].asUInt()); EXPECT_EQ(static_cast<uint32_t>(ButtonName::eType::CUSTOM_BUTTON), res_list[am::strings::application_buttons][1].asUInt()); - EXPECT_EQ(0u, res_list[am::strings::application_vehicle_info][0].asUInt()); - EXPECT_EQ(5u, res_list[am::strings::application_vehicle_info][1].asUInt()); } void ResumptionDataTest::CheckChoiceSet(sm::SmartObject& res_list) { @@ -322,19 +321,22 @@ void ResumptionDataTest::CheckVRTitle( } void ResumptionDataTest::PrepareData() { + mock_app_extension_ = + std::make_shared<NiceMock<application_manager_test::MockAppExtension> >(); + extensions_.insert(extensions_.begin(), mock_app_extension_); + ON_CALL(*app_mock, Extensions()).WillByDefault(ReturnRef(extensions_)); SetGlobalProporties(); SetCommands(); SetSubmenues(); SetChoiceSet(); SetAppFiles(); - DataAccessor<am::SubMenuMap> sub_menu_m(test_submenu_map, sublock_); - DataAccessor<am::CommandsMap> commands_m(test_commands_map, comlock_); - DataAccessor<am::ChoiceSetMap> choice_set_m(test_choiceset_map, setlock_); + DataAccessor<am::SubMenuMap> sub_menu_m(test_submenu_map, sublock_ptr_); + DataAccessor<am::CommandsMap> commands_m(test_commands_map, comlock_ptr_); + DataAccessor<am::ChoiceSetMap> choice_set_m(test_choiceset_map, setlock_ptr_); SetSubscriptions(); - DataAccessor<am::ButtonSubscriptions> btn_sub(btn_subscr, btnlock_); - DataAccessor<am::VehicleInfoSubscriptions> ivi_access(ivi, ivilock_); + DataAccessor<am::ButtonSubscriptions> btn_sub(btn_subscr, btnlock_ptr_); ON_CALL(*app_mock, is_application_data_changed()).WillByDefault(Return(true)); @@ -364,7 +366,6 @@ void ResumptionDataTest::PrepareData() { ON_CALL(*app_mock, menu_icon()).WillByDefault(ReturnPointee(&menu_icon_)); ON_CALL(*app_mock, SubscribedButtons()).WillByDefault(Return(btn_sub)); - ON_CALL(*app_mock, SubscribedIVI()).WillByDefault(Return(ivi_access)); ON_CALL(*app_mock, getAppFiles()).WillByDefault(ReturnRef(app_files_map_)); } @@ -381,6 +382,7 @@ void ResumptionDataTest::SetMenuTitleAndIcon() { sm::SmartObject sm_icon; sm_icon[am::strings::value] = "test icon"; sm_icon[am::strings::image_type] = ImageType::STATIC; + sm_icon[am::strings::is_template] = false; sm::SmartObject sm_title; sm_title = "test title"; @@ -539,8 +541,6 @@ void ResumptionDataTest::SetKeyboardProperties() { void ResumptionDataTest::SetSubscriptions() { btn_subscr.insert(ButtonName::eType::CUSTOM_BUTTON); btn_subscr.insert(ButtonName::eType::OK); - ivi.insert(static_cast<mobile_apis::VehicleDataType::eType>(0)); - ivi.insert(static_cast<mobile_apis::VehicleDataType::eType>(5)); } } // namespace resumption_test |