From e10f6296b5050f7b56076bfecdb15be0b955cc3c Mon Sep 17 00:00:00 2001 From: "Andrey Oleynik (GitHub)" Date: Tue, 3 Oct 2017 12:16:57 +0300 Subject: Test coverage for postponing commands during switching --- .../application_manager/test/CMakeLists.txt | 16 +- .../test/application_manager_impl_mock_hmi_test.cc | 239 +++++++++++++++++++++ .../test/application_manager_impl_test.cc | 102 ++++++--- .../test/command_holder_test.cc | 126 +++++++++++ .../mobile/register_app_interface_request_test.cc | 17 +- .../application_manager/mock_hmi_command_factory.h | 57 +++++ .../test/mock_hmi_command_factory.cc | 57 +++++ 7 files changed, 569 insertions(+), 45 deletions(-) create mode 100644 src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc create mode 100644 src/components/application_manager/test/command_holder_test.cc create mode 100644 src/components/application_manager/test/include/application_manager/mock_hmi_command_factory.h create mode 100644 src/components/application_manager/test/mock_hmi_command_factory.cc (limited to 'src') diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt index 100b4c0210..3e9010e22c 100644 --- a/src/components/application_manager/test/CMakeLists.txt +++ b/src/components/application_manager/test/CMakeLists.txt @@ -31,12 +31,6 @@ include(${CMAKE_SOURCE_DIR}/tools/cmake/helpers/platform.cmake) include(${CMAKE_SOURCE_DIR}/tools/cmake/helpers/sources.cmake) -# TODO{ALeshin}: APPLINK-10792. Do not write tests which use -# application manager(AM) singleton while refactoring of AM is finished. - -# TODO{ILytvynenko}: SDLOPEN-797 Uncomment application_manager_impl_test and -# cover with UT missed files. - include_directories( ${GMOCK_INCLUDE_DIRECTORY} ${CMAKE_BINARY_DIR}/src/components/ @@ -68,10 +62,15 @@ set(testSources ${AM_TEST_DIR}/application_state_test.cc ${AM_TEST_DIR}/usage_statistics_test.cc ${AM_TEST_DIR}/policy_handler_test.cc - ${AM_TEST_DIR}/mock_message_helper.cc ${AM_TEST_DIR}/application_manager_impl_test.cc ${AM_TEST_DIR}/application_helper_test.cc + ${AM_TEST_DIR}/command_holder_test.cc +) +set(testSourcesMockHmi + ${AM_SOURCE_DIR}/src/message_helper/message_helper.cc + ${AM_TEST_DIR}/application_manager_impl_mock_hmi_test.cc + ${AM_TEST_DIR}/mock_hmi_command_factory.cc ) if(REMOTE_CONTROL) @@ -131,10 +130,11 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath=${CMAKE_CURRENT_BINARY_DIR}" ) create_test("application_manager_test" "${testSources}" "${LIBRARIES}") +create_test("application_manager_mock_hmi_test" "${testSourcesMockHmi}" "${LIBRARIES}") add_dependencies("application_manager_test" libbson) + create_test("request_controller_test" "${RequestController_SOURCES}" "${LIBRARIES}") -# TODO [AKozoriz] : Fix not buildable tests set(ResumptionData_SOURCES ${AM_TEST_DIR}/resumption/resumption_data_test.cc ${AM_TEST_DIR}/resumption/resumption_data_db_test.cc diff --git a/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc b/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc new file mode 100644 index 0000000000..7ca2ff9d98 --- /dev/null +++ b/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2017, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#include +#include +#include + +#include "gtest/gtest.h" +#include "application_manager/application.h" +#include "application_manager/application_impl.h" +#include "application_manager/application_manager_impl.h" +#include "utils/custom_string.h" +#include "utils/make_shared.h" + +#include "application_manager/mock_application_manager_settings.h" +#include "application_manager/mock_resumption_data.h" +#include "application_manager/mock_hmi_command_factory.h" +#include "application_manager/mock_request.h" +#include "connection_handler/mock_connection_handler.h" +#include "policy/mock_policy_settings.h" +#include "policy/usage_statistics/mock_statistics_manager.h" +#include "protocol_handler/mock_session_observer.h" + +namespace test { +namespace components { +namespace application_manager_test { + +namespace am = application_manager; + +using testing::_; +using ::testing::DoAll; +using ::testing::Mock; +using ::testing::Return; +using ::testing::ReturnRef; +using ::testing::NiceMock; +using ::testing::SetArgPointee; + +using namespace application_manager; + +namespace { +const uint32_t kApplicationId = 0u; +const std::string kDirectoryName = "./test_storage"; +const uint32_t kTimeout = 10000u; +} // namespace + +/** + * @brief The ApplicationManagerImplMockHmiTest class uses mocked HMI factory + * which calls its static method and real (non-mocked) MessageHelper. + * Class is separated from ApplicationManagerImplTest since it requires real + * HMI factory and mocked MessageHelper. So it is not possible to combine + * this code together. + */ +class ApplicationManagerImplMockHmiTest : public ::testing::Test { + public: + ApplicationManagerImplMockHmiTest() + : mock_storage_( + ::utils::MakeShared >( + mock_app_mngr_)) {} + + protected: + void SetUp() OVERRIDE { + const uint8_t expected_tread_pool_size = 2u; + const uint8_t stop_streaming_timeout = 1u; + + ON_CALL(mock_application_manager_settings_, thread_pool_size()) + .WillByDefault(Return(expected_tread_pool_size)); + ON_CALL(mock_application_manager_settings_, app_icons_folder()) + .WillByDefault(ReturnRef(kDirectoryName)); + ON_CALL(mock_application_manager_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kDirectoryName)); + ON_CALL(mock_application_manager_settings_, launch_hmi()) + .WillByDefault(Return(true)); + ON_CALL(mock_application_manager_settings_, stop_streaming_timeout()) + .WillByDefault(Return(stop_streaming_timeout)); + ON_CALL(mock_application_manager_settings_, default_timeout()) + .WillByDefault(ReturnRef(kTimeout)); + + ON_CALL(mock_connection_handler_, get_session_observer()) + .WillByDefault(ReturnRef(mock_session_observer_)); + + app_manager_impl_.reset(new am::ApplicationManagerImpl( + mock_application_manager_settings_, mock_policy_settings_)); + + app_manager_impl_->set_connection_handler(&mock_connection_handler_); + app_manager_impl_->resume_controller().set_resumption_storage( + mock_storage_); + } + + void SetCommonExpectationOnAppReconnection( + const connection_handler::DeviceHandle new_device_id, + const uint32_t new_application_id, + const std::string& mac_address) { + EXPECT_CALL( + mock_session_observer_, + GetDataOnSessionKey(new_application_id, + _, + _, + testing::An())) + .WillOnce(DoAll(SetArgPointee<3u>(new_device_id), Return(0))); + + const std::string connection_type = "MyConnectionType"; + EXPECT_CALL( + mock_session_observer_, + GetDataOnDeviceID( + ::testing::Matcher(new_device_id), + _, + _, + _, + _)) + .WillOnce(DoAll(SetArgPointee<3u>(mac_address), + SetArgPointee<4u>(connection_type), + Return(0))); + } + + utils::SharedPtr > + mock_storage_; + application_manager_test::MockApplicationManager mock_app_mngr_; + NiceMock mock_policy_settings_; + NiceMock + mock_connection_handler_; + NiceMock mock_session_observer_; + NiceMock mock_application_manager_settings_; + std::unique_ptr app_manager_impl_; +}; + +TEST_F(ApplicationManagerImplMockHmiTest, + PostponeCommandsDuringSwitching_ExpectSendingOnSwitchingEnd) { + const uint32_t application_id = 1u; + const std::string policy_app_id = "p_app_id"; + const std::string mac_address = "MA:CA:DD:RE:SS"; + const connection_handler::DeviceHandle device_id = 1u; + const custom_str::CustomString app_name(""); + + utils::SharedPtr app_impl = new ApplicationImpl( + application_id, + policy_app_id, + mac_address, + device_id, + app_name, + utils::SharedPtr( + new usage_statistics_test::MockStatisticsManager()), + *app_manager_impl_); + + app_manager_impl_->AddMockApplication(app_impl); + + app_manager_impl_->OnDeviceSwitchingStart(mac_address); + + MockHMICommandFactory* mock_hmi_factory = + MockHMICommandFactory::mock_hmi_command_factory(); + + const uint32_t connection_key = 1u; + const uint32_t correlation_id_1 = 1u; + const uint32_t correlation_id_2 = 2u; + const uint32_t correlation_id_3 = 3u; + utils::SharedPtr > cmd_1 = + utils::MakeShared >(connection_key, + correlation_id_1); + utils::SharedPtr > cmd_2 = + utils::MakeShared >(connection_key, + correlation_id_2); + utils::SharedPtr > cmd_3 = + utils::MakeShared >(connection_key, + correlation_id_3); + + EXPECT_CALL(*mock_hmi_factory, CreateCommand(_, _)) + .WillOnce(Return(cmd_1)) + .WillOnce(Return(cmd_2)) + .WillOnce(Return(cmd_3)); + + commands::MessageSharedPtr hmi_msg_1 = + utils::MakeShared(); + commands::MessageSharedPtr hmi_msg_2 = + utils::MakeShared(); + commands::MessageSharedPtr hmi_msg_3 = + utils::MakeShared(); + + EXPECT_CALL(*cmd_1, Init()).Times(0); + EXPECT_CALL(*cmd_2, Init()).Times(0); + EXPECT_CALL(*cmd_3, Init()).Times(0); + + // Act + app_manager_impl_->ManageHMICommand(hmi_msg_1); + app_manager_impl_->ManageHMICommand(hmi_msg_2); + app_manager_impl_->ManageHMICommand(hmi_msg_3); + + EXPECT_CALL(*mock_hmi_factory, CreateCommand(_, _)) + .WillOnce(Return(cmd_1)) + .WillOnce(Return(cmd_2)) + .WillOnce(Return(cmd_3)); + + EXPECT_CALL(*cmd_1, Init()).WillOnce(Return(true)); + EXPECT_CALL(*cmd_1, Run()); + EXPECT_CALL(*cmd_2, Init()).WillOnce(Return(true)); + EXPECT_CALL(*cmd_2, Run()); + EXPECT_CALL(*cmd_3, Init()).WillOnce(Return(true)); + EXPECT_CALL(*cmd_3, Run()); + + const connection_handler::DeviceHandle new_device_id = 2; + const uint32_t new_application_id = 2; + SetCommonExpectationOnAppReconnection( + new_device_id, new_application_id, mac_address); + + app_manager_impl_->ProcessReconnection(app_impl, new_application_id); + app_manager_impl_->OnApplicationSwitched(app_impl); + + Mock::VerifyAndClearExpectations(&mock_hmi_factory); +} + +} // application_manager_test +} // namespace components +} // namespace test diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc index 0d659e3557..16ca54b903 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -94,7 +94,7 @@ class ApplicationManagerImplTest : public ::testing::Test { ApplicationManagerImplTest() : mock_storage_( ::utils::MakeShared >( - app_mngr_)) + mock_app_mngr_)) , mock_message_helper_( application_manager::MockMessageHelper::message_helper_mock()) , app_id_(0u) { @@ -148,13 +148,39 @@ class ApplicationManagerImplTest : public ::testing::Test { app_manager_impl_->AddMockApplication(mock_app_ptr_); } + void SetCommonExpectationOnAppReconnection( + const connection_handler::DeviceHandle new_device_id, + const uint32_t new_application_id, + const std::string& mac_address) { + EXPECT_CALL( + mock_session_observer_, + GetDataOnSessionKey(new_application_id, + _, + _, + testing::An())) + .WillOnce(DoAll(SetArgPointee<3u>(new_device_id), Return(0))); + + const std::string connection_type = "MyConnectionType"; + EXPECT_CALL( + mock_session_observer_, + GetDataOnDeviceID( + ::testing::Matcher(new_device_id), + _, + _, + _, + _)) + .WillOnce(DoAll(SetArgPointee<3u>(mac_address), + SetArgPointee<4u>(connection_type), + Return(0))); + } + NiceMock mock_policy_settings_; utils::SharedPtr > mock_storage_; NiceMock mock_connection_handler_; NiceMock mock_session_observer_; NiceMock mock_application_manager_settings_; - application_manager_test::MockApplicationManager app_mngr_; + application_manager_test::MockApplicationManager mock_app_mngr_; std::auto_ptr app_manager_impl_; application_manager::MockMessageHelper* mock_message_helper_; uint32_t app_id_; @@ -646,10 +672,10 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr switching_app_ptr = utils::MakeShared(); - const std::string switching_device_id = "switching"; + const std::string switching_mac_address = "switching"; app_manager_impl_->AddMockApplication(switching_app_ptr); EXPECT_CALL(*switching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(switching_device_id)); + .WillRepeatedly(ReturnRef(switching_mac_address)); const std::string policy_app_id_switch = "abc"; EXPECT_CALL(*switching_app_ptr, policy_app_id()) @@ -658,17 +684,17 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr nonswitching_app_ptr = utils::MakeShared(); - const std::string nonswitching_device_id = "nonswitching"; + const std::string nonswitching_mac_address = "nonswitching"; app_manager_impl_->AddMockApplication(nonswitching_app_ptr); EXPECT_CALL(*nonswitching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(nonswitching_device_id)); + .WillRepeatedly(ReturnRef(nonswitching_mac_address)); const std::string policy_app_id_nonswitch = "efg"; EXPECT_CALL(*nonswitching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_nonswitch)); // Act - app_manager_impl_->OnDeviceSwitchingStart(switching_device_id); + app_manager_impl_->OnDeviceSwitchingStart(switching_mac_address); EXPECT_TRUE(app_manager_impl_->IsAppInReconnectMode(policy_app_id_switch)); EXPECT_FALSE( app_manager_impl_->IsAppInReconnectMode(policy_app_id_nonswitch)); @@ -679,10 +705,18 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr switching_app_ptr = utils::MakeShared(); - const std::string switching_device_id = "switching"; + const uint32_t switching_app_id = 1u; + EXPECT_CALL(*switching_app_ptr, app_id()) + .WillRepeatedly(Return(switching_app_id)); + + const uint32_t switching_device_id = 1u; + EXPECT_CALL(*switching_app_ptr, device()) + .WillRepeatedly(Return(switching_device_id)); + + const std::string switching_mac_address = "switching"; app_manager_impl_->AddMockApplication(switching_app_ptr); EXPECT_CALL(*switching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(switching_device_id)); + .WillRepeatedly(ReturnRef(switching_mac_address)); const std::string policy_app_id_switch = "abc"; EXPECT_CALL(*switching_app_ptr, policy_app_id()) @@ -691,22 +725,42 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr nonswitching_app_ptr = utils::MakeShared(); - const std::string nonswitching_device_id = "nonswitching"; + const uint32_t nonswitching_app_id = 2u; + EXPECT_CALL(*nonswitching_app_ptr, app_id()) + .WillRepeatedly(Return(nonswitching_app_id)); + + const uint32_t nonswitching_device_id = 2u; + EXPECT_CALL(*nonswitching_app_ptr, device()) + .WillRepeatedly(Return(nonswitching_device_id)); + + const std::string nonswitching_mac_address = "nonswitching"; app_manager_impl_->AddMockApplication(nonswitching_app_ptr); EXPECT_CALL(*nonswitching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(nonswitching_device_id)); + .WillRepeatedly(ReturnRef(nonswitching_mac_address)); const std::string policy_app_id_nonswitch = "efg"; EXPECT_CALL(*nonswitching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_nonswitch)); // Act - app_manager_impl_->OnDeviceSwitchingStart(switching_device_id); + app_manager_impl_->OnDeviceSwitchingStart(switching_mac_address); EXPECT_TRUE(app_manager_impl_->IsAppInReconnectMode(policy_app_id_switch)); + EXPECT_FALSE( + app_manager_impl_->IsAppInReconnectMode(policy_app_id_nonswitch)); + + smart_objects::SmartObjectSPtr sptr = + MakeShared(); + + ON_CALL(*mock_message_helper_, CreateModuleInfoSO(_, _)) + .WillByDefault(Return(sptr)); + ON_CALL(*mock_message_helper_, CreateNegativeResponse(_, _, _, _)) + .WillByDefault(Return(sptr)); - app_manager_impl_->OnDeviceSwitchFinish(switching_device_id); + app_manager_impl_->OnDeviceSwitchFinish(switching_mac_address); EXPECT_FALSE( app_manager_impl_->application_by_policy_id(policy_app_id_switch)); + EXPECT_TRUE( + app_manager_impl_->application_by_policy_id(policy_app_id_nonswitch)); } TEST_F(ApplicationManagerImplTest, @@ -731,26 +785,8 @@ TEST_F(ApplicationManagerImplTest, const connection_handler::DeviceHandle new_device_id = 2; const uint32_t new_application_id = 2; - EXPECT_CALL( - mock_session_observer_, - GetDataOnSessionKey(new_application_id, - _, - _, - testing::An())) - .WillOnce(DoAll(SetArgPointee<3u>(new_device_id), Return(0))); - - const std::string connection_type = "MyConnectionType"; - EXPECT_CALL( - mock_session_observer_, - GetDataOnDeviceID( - ::testing::Matcher(new_device_id), - _, - _, - _, - _)) - .WillOnce(DoAll(SetArgPointee<3u>(mac_address), - SetArgPointee<4u>(connection_type), - Return(0))); + SetCommonExpectationOnAppReconnection( + new_device_id, new_application_id, mac_address); // Act app_manager_impl_->ProcessReconnection(app_impl, new_application_id); diff --git a/src/components/application_manager/test/command_holder_test.cc b/src/components/application_manager/test/command_holder_test.cc new file mode 100644 index 0000000000..0a365dca73 --- /dev/null +++ b/src/components/application_manager/test/command_holder_test.cc @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2017, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include "application_manager/command_holder_impl.h" +#include "smart_objects/smart_object.h" +#include "utils/shared_ptr.h" + +#include "application_manager/mock_application_manager.h" + +namespace test { +namespace components { +namespace application_manager_test { + +using testing::_; + +namespace am = application_manager; + +class CommandHolderImplTest : public testing::Test { + public: + CommandHolderImplTest() + : cmd_ptr_(new smart_objects::SmartObject), kPolicyAppId_("p_app_id") {} + + MockApplicationManager mock_app_manager_; + utils::SharedPtr cmd_ptr_; + const std::string kPolicyAppId_; +}; + +TEST_F(CommandHolderImplTest, HoldOne_ExpectReleaseOne) { + am::CommandHolderImpl cmd_holder; + cmd_holder.SetCommandsProcessor(&mock_app_manager_); + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + + // Act + EXPECT_CALL(mock_app_manager_, ManageHMICommand(cmd_ptr_)); + cmd_holder.Release(kPolicyAppId_); +} + +TEST_F(CommandHolderImplTest, HoldMany_ExpectReleaseSame) { + am::CommandHolderImpl cmd_holder; + cmd_holder.SetCommandsProcessor(&mock_app_manager_); + + int32_t iterations = 0; + do { + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + ++iterations; + } while (iterations < 5); + + // Act + EXPECT_CALL(mock_app_manager_, ManageHMICommand(cmd_ptr_)).Times(iterations); + cmd_holder.Release(kPolicyAppId_); +} + +TEST_F(CommandHolderImplTest, Hold_Drop_ExpectNoReleased) { + am::CommandHolderImpl cmd_holder; + cmd_holder.SetCommandsProcessor(&mock_app_manager_); + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + + // Act + cmd_holder.Drop(kPolicyAppId_); + EXPECT_CALL(mock_app_manager_, ManageHMICommand(cmd_ptr_)).Times(0); + cmd_holder.Release(kPolicyAppId_); +} + +TEST_F(CommandHolderImplTest, Hold_ReleaseAnotherId_ExpectNoReleased) { + am::CommandHolderImpl cmd_holder; + cmd_holder.SetCommandsProcessor(&mock_app_manager_); + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + + // Act + EXPECT_CALL(mock_app_manager_, ManageHMICommand(cmd_ptr_)).Times(0); + cmd_holder.Release("anotherId"); +} + +TEST_F(CommandHolderImplTest, Hold_DropAnotherId_ExpectReleased) { + am::CommandHolderImpl cmd_holder; + cmd_holder.SetCommandsProcessor(&mock_app_manager_); + + int32_t iterations = 0; + do { + cmd_holder.Hold(kPolicyAppId_, cmd_ptr_); + ++iterations; + } while (iterations < 3); + + // Act + cmd_holder.Drop("anotherId"); + + EXPECT_CALL(mock_app_manager_, ManageHMICommand(cmd_ptr_)).Times(iterations); + cmd_holder.Release(kPolicyAppId_); +} + +} // application_manager_test +} // components +} // test diff --git a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc index 9dca9a23e8..b0928044fc 100644 --- a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc @@ -185,7 +185,7 @@ class RegisterAppInterfaceRequestTest } void SetCommonExpectionsOnSwitchedApplication( - mobile_apis::Result::eType response_result_code) { + MockAppPtr mock_app, mobile_apis::Result::eType response_result_code) { EXPECT_CALL(mock_policy_handler_, AddApplication(_, _)).Times(0); EXPECT_CALL( @@ -213,6 +213,12 @@ class RegisterAppInterfaceRequestTest EXPECT_CALL(app_mngr_, ManageHMICommand(HMIResultCodeIs( hmi_apis::FunctionID::VR_ChangeRegistration))).Times(0); + + EXPECT_CALL( + app_mngr_, + OnApplicationSwitched( + MockAppPtr::static_pointer_cast( + mock_app))); } MessageSharedPtr msg_; @@ -439,7 +445,8 @@ TEST_F(RegisterAppInterfaceRequestTest, EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillRepeatedly(Return(mock_app)); - SetCommonExpectionsOnSwitchedApplication(mobile_apis::Result::SUCCESS); + SetCommonExpectionsOnSwitchedApplication(mock_app, + mobile_apis::Result::SUCCESS); command_->Run(); } @@ -482,7 +489,8 @@ TEST_F(RegisterAppInterfaceRequestTest, EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillRepeatedly(Return(mock_app)); - SetCommonExpectionsOnSwitchedApplication(mobile_apis::Result::RESUME_FAILED); + SetCommonExpectionsOnSwitchedApplication(mock_app, + mobile_apis::Result::RESUME_FAILED); command_->Run(); } @@ -515,7 +523,8 @@ TEST_F(RegisterAppInterfaceRequestTest, EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillRepeatedly(Return(mock_app)); - SetCommonExpectionsOnSwitchedApplication(mobile_apis::Result::RESUME_FAILED); + SetCommonExpectionsOnSwitchedApplication(mock_app, + mobile_apis::Result::RESUME_FAILED); command_->Run(); } diff --git a/src/components/application_manager/test/include/application_manager/mock_hmi_command_factory.h b/src/components/application_manager/test/include/application_manager/mock_hmi_command_factory.h new file mode 100644 index 0000000000..6ff40394a2 --- /dev/null +++ b/src/components/application_manager/test/include/application_manager/mock_hmi_command_factory.h @@ -0,0 +1,57 @@ +/* + Copyright (c) 2017, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include +#include "application_manager/application_manager.h" +#include "application_manager/commands/command.h" +#include "smart_objects/smart_object.h" +#include "utils/shared_ptr.h" + +namespace test { +namespace components { +namespace application_manager_test { + +class MockHMICommandFactory { + public: + MOCK_METHOD2(CreateCommand, + utils::SharedPtr( + const utils::SharedPtr&, + application_manager::ApplicationManager&)); + + static MockHMICommandFactory* mock_hmi_command_factory(); +}; + +} // application_manager +} // components +} // test diff --git a/src/components/application_manager/test/mock_hmi_command_factory.cc b/src/components/application_manager/test/mock_hmi_command_factory.cc new file mode 100644 index 0000000000..19ad44f482 --- /dev/null +++ b/src/components/application_manager/test/mock_hmi_command_factory.cc @@ -0,0 +1,57 @@ +/* + Copyright (c) 2017, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include "application_manager/hmi_command_factory.h" +#include "application_manager/mock_hmi_command_factory.h" + +namespace test { +namespace components { +namespace application_manager_test { + +MockHMICommandFactory* MockHMICommandFactory::mock_hmi_command_factory() { + static MockHMICommandFactory mock_hmi_command_factory; + return &mock_hmi_command_factory; +} + +} // application_manager +} // components +} // test + +namespace application_manager { +CommandSharedPtr HMICommandFactory::CreateCommand( + const commands::MessageSharedPtr& message, + ApplicationManager& application_manager) { + return test::components::application_manager_test::MockHMICommandFactory:: + mock_hmi_command_factory()->CreateCommand(message, application_manager); +} +} // application_manager -- cgit v1.2.1