diff options
Diffstat (limited to 'src/components/application_manager/test/include/application_manager')
12 files changed, 382 insertions, 47 deletions
diff --git a/src/components/application_manager/test/include/application_manager/commands/commands_test.h b/src/components/application_manager/test/include/application_manager/commands/commands_test.h index cd0514a0da..fdaef2c716 100644 --- a/src/components/application_manager/test/include/application_manager/commands/commands_test.h +++ b/src/components/application_manager/test/include/application_manager/commands/commands_test.h @@ -30,8 +30,8 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_TEST_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_TEST_H_ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_COMMANDS_TEST_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_COMMANDS_TEST_H_ #include <stdint.h> #include "gtest/gtest.h" @@ -245,6 +245,21 @@ MATCHER_P(HMIResultCodeIs, result_code, "") { .asInt()); } +MATCHER_P3( + HMIMessageParametersAre, correlation_id, function_id, result_code, "") { + using namespace application_manager; + + const bool corr_ids_eq = + correlation_id == + (*arg)[strings::params][strings::correlation_id].asInt(); + const bool func_ids_eq = + (*arg)[strings::params][strings::function_id].asInt() == function_id; + const bool res_codes_eq = + (*arg)[strings::params][hmi_response::code].asInt() == result_code; + + return corr_ids_eq && func_ids_eq && res_codes_eq; +} + MATCHER_P3(MobileResponseIs, result_code, result_info, result_success, "") { mobile_apis::Result::eType code = static_cast<mobile_apis::Result::eType>( (*arg)[am::strings::msg_params][am::strings::result_code].asInt()); @@ -259,4 +274,4 @@ MATCHER_P3(MobileResponseIs, result_code, result_info, result_success, "") { } // namespace components } // namespace test -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_TEST_H_ +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_COMMANDS_COMMANDS_TEST_H_ diff --git a/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h b/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h index f77b5685da..60d2f90297 100644 --- a/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h +++ b/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h @@ -37,6 +37,7 @@ #include "application_manager/app_service_manager.h" #include "application_manager/commands/command.h" #include "application_manager/commands/command_impl.h" +#include "application_manager/rpc_passing_handler.h" namespace test { namespace components { @@ -45,7 +46,7 @@ namespace application_manager_test { class MockAppServiceManager : public application_manager::AppServiceManager { public: MockAppServiceManager(application_manager::ApplicationManager& app_manager, - resumption::LastState& last_state) + resumption::LastStateWrapperPtr last_state) : application_manager::AppServiceManager(app_manager, last_state) {} MOCK_METHOD3( PublishAppService, @@ -86,6 +87,7 @@ class MockAppServiceManager : public application_manager::AppServiceManager { const bool service_published)); MOCK_METHOD1(UpdateNavigationCapabilities, bool(smart_objects::SmartObject& out_params)); + MOCK_METHOD0(GetRPCPassingHandler, application_manager::RPCPassingHandler&()); }; } // namespace application_manager_test diff --git a/src/components/application_manager/test/include/application_manager/mock_application.h b/src/components/application_manager/test/include/application_manager/mock_application.h index 65447b61c5..6eb56cb53e 100644 --- a/src/components/application_manager/test/include/application_manager/mock_application.h +++ b/src/components/application_manager/test/include/application_manager/mock_application.h @@ -34,6 +34,8 @@ #include <string> #include "application_manager/app_extension.h" #include "application_manager/application.h" +#include "application_manager/display_capabilities_builder.h" +#include "application_manager/hmi_state.h" #include "application_manager/usage_statistics.h" #include "gmock/gmock.h" #include "smart_objects/smart_object.h" @@ -56,6 +58,8 @@ class MockApplication : public ::application_manager::Application { MOCK_CONST_METHOD0(is_application_data_changed, bool()); MOCK_METHOD1(set_is_application_data_changed, void(bool state_application_data)); + MOCK_CONST_METHOD0(is_app_data_resumption_allowed, bool()); + MOCK_METHOD1(set_app_data_resumption_allowance, void(bool allowed)); MOCK_METHOD0(CloseActiveMessage, void()); MOCK_CONST_METHOD0(IsFullscreen, bool()); MOCK_METHOD0(ChangeSupportingAppHMIType, void()); @@ -82,8 +86,9 @@ class MockApplication : public ::application_manager::Application { void(protocol_handler::ServiceType service_type)); MOCK_METHOD1(SuspendStreaming, void(protocol_handler::ServiceType service_type)); - MOCK_METHOD1(WakeUpStreaming, - void(protocol_handler::ServiceType service_type)); + MOCK_METHOD2(WakeUpStreaming, + void(protocol_handler::ServiceType service_type, + uint32_t timer_len)); MOCK_CONST_METHOD0(is_voice_communication_supported, bool()); MOCK_METHOD1(set_voice_communication_supported, void(bool is_voice_communication_supported)); @@ -97,11 +102,15 @@ class MockApplication : public ::application_manager::Application { MOCK_METHOD1(set_folder_name, void(const std::string& folder_name)); MOCK_CONST_METHOD0(folder_name, const std::string()); MOCK_CONST_METHOD0(is_media_application, bool()); - MOCK_CONST_METHOD0(hmi_level, const mobile_apis::HMILevel::eType()); + MOCK_CONST_METHOD1(hmi_level, + const mobile_apis::HMILevel::eType( + const application_manager::WindowID window_id)); MOCK_CONST_METHOD0(put_file_in_none_count, const uint32_t()); MOCK_CONST_METHOD0(delete_file_in_none_count, const uint32_t()); MOCK_CONST_METHOD0(list_files_in_none_count, const uint32_t()); - MOCK_CONST_METHOD0(system_context, const mobile_apis::SystemContext::eType()); + MOCK_CONST_METHOD1(system_context, + const mobile_apis::SystemContext::eType( + const application_manager::WindowID window_id)); MOCK_CONST_METHOD0(audio_streaming_state, const mobile_apis::AudioStreamingState::eType()); MOCK_CONST_METHOD0(video_streaming_state, @@ -109,11 +118,20 @@ class MockApplication : public ::application_manager::Application { MOCK_CONST_METHOD0(app_icon_path, const std::string&()); MOCK_CONST_METHOD0(device, connection_handler::DeviceHandle()); MOCK_CONST_METHOD0(secondary_device, connection_handler::DeviceHandle()); - MOCK_CONST_METHOD0(CurrentHmiState, const application_manager::HmiStatePtr()); - MOCK_CONST_METHOD0(RegularHmiState, const application_manager::HmiStatePtr()); + MOCK_CONST_METHOD1(CurrentHmiState, + const application_manager::HmiStatePtr( + const application_manager::WindowID window_id)); + MOCK_CONST_METHOD1(RegularHmiState, + const application_manager::HmiStatePtr( + const application_manager::WindowID window_id)); + MOCK_CONST_METHOD0(GetWindowIds, application_manager::WindowIds()); + MOCK_CONST_METHOD0(GetWindowNames, application_manager::WindowNames()); + MOCK_CONST_METHOD1(WindowIdExists, + bool(const application_manager::WindowID window_id)); MOCK_CONST_METHOD0(IsAllowedToChangeAudioSource, bool()); - MOCK_CONST_METHOD0(PostponedHmiState, - const application_manager::HmiStatePtr()); + MOCK_CONST_METHOD1(PostponedHmiState, + const application_manager::HmiStatePtr( + const application_manager::WindowID window_id)); MOCK_METHOD1(set_tts_properties_in_none, void(bool active)); MOCK_METHOD0(tts_properties_in_none, bool()); MOCK_METHOD1(set_tts_properties_in_full, void(bool active)); @@ -167,14 +185,24 @@ class MockApplication : public ::application_manager::Application { ::application_manager::HelpPromptManager&()); MOCK_CONST_METHOD0(help_prompt_manager, const ::application_manager::HelpPromptManager&()); - MOCK_METHOD1(SetInitialState, void(::application_manager::HmiStatePtr state)); - MOCK_METHOD1(SetRegularState, void(::application_manager::HmiStatePtr state)); - MOCK_METHOD1(SetPostponedState, - void(::application_manager::HmiStatePtr state)); - MOCK_METHOD0(RemovePostponedState, void()); - MOCK_METHOD1(AddHMIState, void(::application_manager::HmiStatePtr state)); - MOCK_METHOD1(RemoveHMIState, - void(::application_manager::HmiState::StateID state_id)); + MOCK_METHOD3(SetInitialState, + void(const application_manager::WindowID window_id, + const std::string& window_name, + application_manager::HmiStatePtr state)); + MOCK_METHOD2(SetRegularState, + void(const application_manager::WindowID window_id, + application_manager::HmiStatePtr state)); + MOCK_METHOD2(SetPostponedState, + void(const application_manager::WindowID window_id, + ::application_manager::HmiStatePtr state)); + MOCK_METHOD1(RemovePostponedState, + void(const application_manager::WindowID window_id)); + MOCK_METHOD2(AddHMIState, + void(const application_manager::WindowID window_id, + application_manager::HmiStatePtr state)); + MOCK_METHOD2(RemoveHMIState, + void(const application_manager::WindowID window_id, + ::application_manager::HmiState::StateID state_id)); MOCK_METHOD2(SubscribeToSoftButtons, void(int32_t cmd_id, const ::application_manager::SoftButtonID& softbuttons_id)); @@ -220,9 +248,35 @@ class MockApplication : public ::application_manager::Application { MOCK_CONST_METHOD0(keyboard_props, const smart_objects::SmartObject*()); MOCK_CONST_METHOD0(menu_title, const smart_objects::SmartObject*()); MOCK_CONST_METHOD0(menu_icon, const smart_objects::SmartObject*()); - MOCK_CONST_METHOD0(day_color_scheme, const smart_objects::SmartObject*()); - MOCK_CONST_METHOD0(night_color_scheme, const smart_objects::SmartObject*()); - MOCK_CONST_METHOD0(display_layout, const std::string&()); + MOCK_CONST_METHOD0(day_color_scheme, smart_objects::SmartObject()); + MOCK_CONST_METHOD0(night_color_scheme, smart_objects::SmartObject()); + MOCK_CONST_METHOD0(display_layout, std::string()); + MOCK_CONST_METHOD0(display_capabilities, smart_objects::SmartObjectSPtr()); + MOCK_CONST_METHOD1(display_capabilities, + smart_objects::SmartObjectSPtr( + const application_manager::WindowID window_id)); + + MOCK_METHOD2(set_window_layout, + void(const application_manager::WindowID window_id, + const std::string& layout)); + MOCK_METHOD2(set_day_color_scheme, + void(const application_manager::WindowID window_id, + const smart_objects::SmartObject& color_scheme)); + MOCK_METHOD2(set_night_color_scheme, + void(const application_manager::WindowID window_id, + const smart_objects::SmartObject& color_scheme)); + MOCK_CONST_METHOD1( + window_layout, + std::string(const application_manager::WindowID window_id)); + MOCK_CONST_METHOD1(day_color_scheme, + smart_objects::SmartObject( + const application_manager::WindowID window_id)); + MOCK_CONST_METHOD1(night_color_scheme, + smart_objects::SmartObject( + const application_manager::WindowID window_id)); + MOCK_METHOD1(set_display_capabilities, + void(const smart_objects::SmartObject& display_capabilities)); + MOCK_METHOD1(load_global_properties, void(const smart_objects::SmartObject& so)); MOCK_METHOD1(set_help_prompt, @@ -317,9 +371,10 @@ class MockApplication : public ::application_manager::Application { SwapMobileMessageQueue, void(::application_manager::MobileMessageQueue& mobile_messages)); - MOCK_METHOD1( + MOCK_METHOD2( set_system_context, - void(const application_manager::mobile_api::SystemContext::eType&)); + void(const application_manager::WindowID window_id, + const application_manager::mobile_api::SystemContext::eType&)); MOCK_METHOD1( set_audio_streaming_state, void(const application_manager::mobile_api::AudioStreamingState::eType& @@ -330,9 +385,10 @@ class MockApplication : public ::application_manager::Application { bool(smart_objects::SmartObject module)); MOCK_METHOD1(UnsubscribeFromInteriorVehicleData, bool(smart_objects::SmartObject module)); - MOCK_METHOD1( + MOCK_METHOD2( set_hmi_level, - void(const application_manager::mobile_api::HMILevel::eType& hmi_level)); + void(const application_manager::WindowID window_id, + const application_manager::mobile_api::HMILevel::eType& hmi_level)); MOCK_METHOD1(QueryInterface, application_manager::AppExtensionPtr( application_manager::AppExtensionUID uid)); @@ -358,6 +414,24 @@ class MockApplication : public ::application_manager::Application { void(const mobile_apis::HybridAppPreference::eType& hybrid_app_preference)); MOCK_METHOD1(set_cloud_app_certificate, void(const std::string& certificate)); + MOCK_METHOD2(SetWindowInfo, + void(const ::application_manager::WindowID windowID, + const smart_objects::SmartObject& window_info)); + MOCK_METHOD1(RemoveWindowInfo, + void((const ::application_manager::WindowID window_id))); + MOCK_CONST_METHOD0(window_optional_params_map, + DataAccessor< ::application_manager::WindowParamsMap>()); + MOCK_METHOD0(display_capabilities_builder, + application_manager::DisplayCapabilitiesBuilder&()); + MOCK_METHOD1(GetSoftButtonWindowID, + application_manager::WindowID(const uint32_t button_id)); + MOCK_METHOD1(remove_window_capability, + void(const application_manager::WindowID window_id)); + MOCK_CONST_METHOD1(menu_layout_supported, + bool(const mobile_apis::MenuLayout::eType layout)); + MOCK_METHOD1(set_user_location, + void(const smart_objects::SmartObject& user_location)); + MOCK_CONST_METHOD0(get_user_location, const smart_objects::SmartObject&()); }; } // namespace application_manager_test diff --git a/src/components/application_manager/test/include/application_manager/mock_command_holder.h b/src/components/application_manager/test/include/application_manager/mock_command_holder.h new file mode 100644 index 0000000000..0391808126 --- /dev/null +++ b/src/components/application_manager/test/include/application_manager/mock_command_holder.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2020, 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. + */ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_COMMAND_HOLDER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_COMMAND_HOLDER_H_ +#include "application_manager/command_holder.h" +#include "gmock/gmock.h" + +namespace test { +namespace components { +namespace application_manager_test { + +class MockCommandHolder : public application_manager::CommandHolder { + public: + MOCK_METHOD4( + Suspend, + void(application_manager::ApplicationSharedPtr application, + application_manager::CommandHolder::CommandType type, + application_manager::commands::Command::CommandSource source, + smart_objects::SmartObjectSPtr command)); + MOCK_METHOD2(Resume, + void(application_manager::ApplicationSharedPtr application, + application_manager::CommandHolder::CommandType type)); + MOCK_METHOD1(Clear, + void(application_manager::ApplicationSharedPtr application)); +}; + +} // namespace application_manager_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_COMMAND_HOLDER_H_ diff --git a/src/components/application_manager/test/include/application_manager/mock_hmi_capabilities.h b/src/components/application_manager/test/include/application_manager/mock_hmi_capabilities.h index 21641d8ab4..b2753fc8a4 100644 --- a/src/components/application_manager/test/include/application_manager/mock_hmi_capabilities.h +++ b/src/components/application_manager/test/include/application_manager/mock_hmi_capabilities.h @@ -99,55 +99,64 @@ class MockHMICapabilities : public ::application_manager::HMICapabilities { MOCK_METHOD1(set_tts_supported_languages, void(const smart_objects::SmartObject& supported_languages)); - MOCK_CONST_METHOD0(display_capabilities, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(display_capabilities, + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_display_capabilities, void(const smart_objects::SmartObject& display_capabilities)); + MOCK_CONST_METHOD0(system_display_capabilities, + const smart_objects::SmartObjectSPtr()); + MOCK_METHOD1(set_system_display_capabilities, + void(const smart_objects::SmartObject& display_capabilities)); + MOCK_CONST_METHOD0(hmi_zone_capabilities, - const smart_objects::SmartObject*()); + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_hmi_zone_capabilities, void(const smart_objects::SmartObject& hmi_zone_capabilities)); MOCK_CONST_METHOD0(soft_button_capabilities, - const smart_objects::SmartObject*()); + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1( set_soft_button_capabilities, void(const smart_objects::SmartObject& soft_button_capabilities)); - MOCK_CONST_METHOD0(button_capabilities, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(button_capabilities, + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_button_capabilities, void(const smart_objects::SmartObject& button_capabilities)); - MOCK_CONST_METHOD0(speech_capabilities, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(speech_capabilities, + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_speech_capabilities, void(const smart_objects::SmartObject& speech_capabilities)); - MOCK_CONST_METHOD0(vr_capabilities, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(vr_capabilities, const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_vr_capabilities, void(const smart_objects::SmartObject& vr_capabilities)); MOCK_CONST_METHOD0(audio_pass_thru_capabilities, - const smart_objects::SmartObject*()); + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1( set_audio_pass_thru_capabilities, void(const smart_objects::SmartObject& audio_pass_thru_capabilities)); MOCK_CONST_METHOD0(pcm_stream_capabilities, - const smart_objects::SmartObject*()); + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_pcm_stream_capabilities, void(const smart_objects::SmartObject& pcm_stream_capabilities)); MOCK_CONST_METHOD0(preset_bank_capabilities, - const smart_objects::SmartObject*()); + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1( set_preset_bank_capabilities, void(const smart_objects::SmartObject& preset_bank_capabilities)); - MOCK_CONST_METHOD0(vehicle_type, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(vehicle_type, const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_vehicle_type, void(const smart_objects::SmartObject& vehicle_type)); - MOCK_CONST_METHOD0(prerecorded_speech, const smart_objects::SmartObject*()); + MOCK_CONST_METHOD0(prerecorded_speech, + const smart_objects::SmartObjectSPtr()); MOCK_METHOD1(set_prerecorded_speech, void(const smart_objects::SmartObject& prerecorded_speech)); @@ -184,14 +193,26 @@ class MockHMICapabilities : public ::application_manager::HMICapabilities { MOCK_METHOD1(set_rc_capability, void(const smart_objects::SmartObject& rc_capability)); +<<<<<<< HEAD MOCK_CONST_METHOD0(driver_distraction_capability, const smart_objects::SmartObject*()); MOCK_METHOD1( set_driver_distraction_capability, void(const smart_objects::SmartObject& driver_distraction_capability)); +======= + MOCK_CONST_METHOD0(seat_location_capability, + const smart_objects::SmartObject*()); + MOCK_METHOD1( + set_seat_location_capability, + void(const smart_objects::SmartObject& seat_location_capability)); + + DEPRECATED +>>>>>>> origin/develop MOCK_METHOD1(Init, void(resumption::LastState* last_state)); + MOCK_METHOD1(Init, void(resumption::LastStateWrapperPtr last_state_wrapper)); + MOCK_CONST_METHOD0(ccpu_version, const std::string&()); MOCK_METHOD1(set_ccpu_version, void(const std::string& ccpu_version)); MOCK_METHOD0(get_hmi_language_handler, @@ -207,6 +228,9 @@ class MockHMICapabilities : public ::application_manager::HMICapabilities { MOCK_CONST_METHOD2(convert_json_languages_to_obj, void(const Json::Value& json_languages, smart_objects::SmartObject& languages)); + MOCK_CONST_METHOD2(convert_audio_capability_to_obj, + void(const Json::Value& capability, + smart_objects::SmartObject& output_so)); }; } // namespace application_manager_test diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h index 29afd36e52..5f6e613123 100644 --- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h +++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h @@ -34,6 +34,7 @@ #define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_MESSAGE_HELPER_H_ #include "application_manager/application.h" #include "application_manager/application_manager.h" +#include "application_manager/hmi_capabilities.h" #include "application_manager/message_helper.h" #include "application_manager/policies/policy_handler_interface.h" #include "gmock/gmock.h" @@ -128,8 +129,9 @@ class MockMessageHelper { MOCK_METHOD2(CreateMessageForHMI, smart_objects::SmartObjectSPtr(hmi_apis::messageType::eType, const uint32_t)); - MOCK_METHOD2(SendHMIStatusNotification, - void(const Application& application_impl, + MOCK_METHOD3(SendHMIStatusNotification, + void(ApplicationSharedPtr application, + const WindowID window_id, ApplicationManager& application_manager)); MOCK_METHOD4(SendPolicyUpdate, void(const std::string& file_path, @@ -153,9 +155,15 @@ class MockMessageHelper { uint32_t correlation_id, ApplicationManager& app_mngr)); #endif // #ifdef EXTERNAL_PROPRIETARY_MODE - MOCK_METHOD3(SendOnPermissionsChangeNotification, + MOCK_METHOD4(SendOnPermissionsChangeNotification, void(uint32_t connection_key, const policy::Permissions& permissions, + ApplicationManager& app_mngr, + const bool require_encryption)); + MOCK_METHOD4(SendPolicySnapshotNotification, + void(uint32_t connection_key, + const std::string& snapshot_file_path, + const std::string& url, ApplicationManager& app_mngr)); MOCK_METHOD4(SendPolicySnapshotNotification, void(uint32_t connection_key, @@ -223,6 +231,11 @@ class MockMessageHelper { ApplicationConstSharedPtr app, const policy::PolicyHandlerInterface& policy_handler, ApplicationManager& app_mngr)); + MOCK_METHOD4(SubscribeApplicationToSoftButton, + void(smart_objects::SmartObject& message_params, + ApplicationSharedPtr app, + int32_t function_id, + const application_manager::WindowID window_id)); MOCK_METHOD3(SubscribeApplicationToSoftButton, void(smart_objects::SmartObject& message_params, ApplicationSharedPtr app, @@ -261,6 +274,9 @@ class MockMessageHelper { void(ApplicationConstSharedPtr app, const bool is_unexpected_disconnect, ApplicationManager& app_mngr)); + MOCK_METHOD2(CreateOnAppPropertiesChangeNotification, + smart_objects::SmartObjectSPtr(const std::string& policy_app_id, + ApplicationManager& app_mngr)); MOCK_METHOD4(SendLaunchApp, void(const uint32_t connection_key, const std::string& urlSchema, @@ -282,6 +298,10 @@ class MockMessageHelper { MOCK_METHOD1(PrintSmartObject, bool(const smart_objects::SmartObject& object)); + + MOCK_METHOD1(ExtractWindowIdFromSmartObject, + WindowID(const smart_objects::SmartObject& s_map)); + MOCK_METHOD3(SendTTSGlobalProperties, void(ApplicationSharedPtr app, const bool default_help_prompt, @@ -320,6 +340,22 @@ class MockMessageHelper { MOCK_METHOD2(BroadcastCapabilityUpdate, void(smart_objects::SmartObject& msg_params, ApplicationManager& app_mngr)); + MOCK_METHOD3(CreateUICreateWindowRequestsToHMI, + smart_objects::SmartObjectList( + ApplicationSharedPtr application, + ApplicationManager& app_manager, + const smart_objects::SmartObject& windows_info)); + MOCK_METHOD2( + CreateDisplayCapabilityUpdateToMobile, + smart_objects::SmartObjectSPtr(const smart_objects::SmartObject&, + application_manager::Application&)); + MOCK_METHOD4(CreateOnServiceUpdateNotification, + smart_objects::SmartObjectSPtr( + const hmi_apis::Common_ServiceType::eType service_type, + const hmi_apis::Common_ServiceEvent::eType service_event, + const hmi_apis::Common_ServiceStatusUpdateReason::eType + service_update_reason, + const uint32_t app_id)); static MockMessageHelper* message_helper_mock(); }; diff --git a/src/components/application_manager/test/include/application_manager/mock_request.h b/src/components/application_manager/test/include/application_manager/mock_request.h index dfc6691ef4..c1cc7f601f 100644 --- a/src/components/application_manager/test/include/application_manager/mock_request.h +++ b/src/components/application_manager/test/include/application_manager/mock_request.h @@ -55,6 +55,9 @@ class MockRequest : public application_manager::commands::Command { MOCK_METHOD0(CleanUp, bool()); MOCK_CONST_METHOD0(default_timeout, uint32_t()); MOCK_CONST_METHOD0(function_id, int32_t()); + MOCK_CONST_METHOD0(window_id, application_manager::WindowID()); + MOCK_METHOD1(set_warning_info, void(const std::string info)); + MOCK_CONST_METHOD0(warning_info, std::string()); MOCK_METHOD0(onTimeOut, void()); MOCK_METHOD0(AllowedToTerminate, bool()); MOCK_METHOD1(SetAllowedToTerminate, void(bool is_allowed)); diff --git a/src/components/application_manager/test/include/application_manager/mock_resume_ctrl.h b/src/components/application_manager/test/include/application_manager/mock_resume_ctrl.h index 4fd3b7fc5a..3935ab7924 100644 --- a/src/components/application_manager/test/include/application_manager/mock_resume_ctrl.h +++ b/src/components/application_manager/test/include/application_manager/mock_resume_ctrl.h @@ -34,7 +34,7 @@ #include "application_manager/application.h" #include "application_manager/resumption/resume_ctrl.h" #include "gmock/gmock.h" -#include "resumption/last_state.h" +#include "resumption/last_state_wrapper.h" namespace test { namespace components { @@ -82,7 +82,9 @@ class MockResumeCtrl : public resumption::ResumeCtrl { MOCK_METHOD1(OnAppActivated, void(app_mngr::ApplicationSharedPtr application)); MOCK_METHOD1(RemoveFromResumption, void(uint32_t app_id)); + DEPRECATED MOCK_METHOD1(Init, bool(resumption::LastState& last_state)); + MOCK_METHOD1(Init, bool(resumption::LastStateWrapperPtr last_state)); MOCK_METHOD2(OnAppRegistrationStart, void(const std::string& policy_app_id, const std::string& device_id)); @@ -94,13 +96,23 @@ class MockResumeCtrl : public resumption::ResumeCtrl { MOCK_METHOD1(SetupDefaultHMILevel, bool(application_manager::ApplicationSharedPtr application)); MOCK_METHOD1(StartAppHmiStateResumption, - void(application_manager::ApplicationSharedPtr application)); + bool(application_manager::ApplicationSharedPtr application)); MOCK_METHOD3(SetAppHMIState, bool(application_manager::ApplicationSharedPtr application, const mobile_apis::HMILevel::eType hmi_level, bool check_policy)); MOCK_CONST_METHOD0(LaunchTime, time_t()); + MOCK_METHOD2(RestoreAppWidgets, + size_t(app_mngr::ApplicationSharedPtr application, + const smart_objects::SmartObject& saved_app)); + + MOCK_METHOD1(RestoreWidgetsHMIState, + void(const smart_objects::SmartObject& response_message)); + + MOCK_METHOD1(StartWaitingForDisplayCapabilitiesUpdate, + void(application_manager::ApplicationSharedPtr application)); + #ifdef BUILD_TESTS MOCK_METHOD1(set_resumption_storage, void(std::shared_ptr<resumption::ResumptionData> mock_storage)); diff --git a/src/components/application_manager/test/include/application_manager/mock_rpc_protection_manager.h b/src/components/application_manager/test/include/application_manager/mock_rpc_protection_manager.h new file mode 100644 index 0000000000..112de0fea5 --- /dev/null +++ b/src/components/application_manager/test/include/application_manager/mock_rpc_protection_manager.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2019, 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. + */ + +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_RPC_PROTECTION_MANAGER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_RPC_PROTECTION_MANAGER_H_ + +#include "application_manager/rpc_protection_manager.h" +#include "gmock/gmock.h" + +namespace application_manager { +class MockRPCProtectionManager : public RPCProtectionManager { + public: + MOCK_CONST_METHOD3(CheckPolicyEncryptionFlag, + bool(const uint32_t function_id, + const ApplicationSharedPtr app, + const bool is_rpc_service_secure)); + + MOCK_METHOD3(CreateEncryptionNeededResponse, + std::shared_ptr<smart_objects::SmartObject>( + const uint32_t connection_key, + const uint32_t function_id, + const uint32_t conrrelation_id)); + + MOCK_CONST_METHOD2(IsInEncryptionNeededCache, + bool(const uint32_t app_id, + const uint32_t conrrelation_id)); + + MOCK_METHOD2(AddToEncryptionNeededCache, + void(const uint32_t app_id, const uint32_t correlation_id)); + + MOCK_METHOD2(RemoveFromEncryptionNeededCache, + void(const uint32_t app_id, const uint32_t correlation_id)); +}; +} // namespace application_manager + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_MOCK_RPC_PROTECTION_MANAGER_H_ diff --git a/src/components/application_manager/test/include/application_manager/mock_rpc_protection_mediator.h b/src/components/application_manager/test/include/application_manager/mock_rpc_protection_mediator.h new file mode 100644 index 0000000000..858673e3b3 --- /dev/null +++ b/src/components/application_manager/test/include/application_manager/mock_rpc_protection_mediator.h @@ -0,0 +1,22 @@ +#pragma once + +#include "application_manager/rpc_protection_mediator.h" +#include "gmock/gmock.h" + +namespace application_manager { +class MockRPCProtectionMediator : public RPCProtectionMediator { + public: + MOCK_METHOD4(DoesRPCNeedEncryption, + bool(const uint32_t function_id, + std::shared_ptr<Application> app, + const uint32_t conrrelation_id, + const bool is_rpc_service_secure)); + MOCK_METHOD1(DoesRPCNeedEncryption, bool(const uint32_t conrrelation_id)); + MOCK_METHOD1(EncryptResponseByForce, void(const uint32_t conrrelation_id)); + MOCK_METHOD3(CreateNegativeResponse, + std::shared_ptr<smart_objects::SmartObject>( + const uint32_t connection_key, + const uint32_t function_id, + const uint32_t conrrelation_id)); +}; +} // namespace application_manager diff --git a/src/components/application_manager/test/include/application_manager/resumption_data_test.h b/src/components/application_manager/test/include/application_manager/resumption_data_test.h index cab3c23253..e38b428877 100644 --- a/src/components/application_manager/test/include/application_manager/resumption_data_test.h +++ b/src/components/application_manager/test/include/application_manager/resumption_data_test.h @@ -63,7 +63,15 @@ using namespace mobile_apis; class ResumptionDataTest : public ::testing::Test { protected: ResumptionDataTest() - : kCountOfCommands_(5u) + : help_prompt_(NULL) + , timeout_prompt_(NULL) + , vr_help_(NULL) + , vr_help_title_(NULL) + , vr_synonyms_(NULL) + , keyboard_props_(NULL) + , menu_title_(NULL) + , menu_icon_(NULL) + , kCountOfCommands_(5u) , kCountOfChoice_(2u) , kCountOfChoiceSets_(4u) , kCountOfSubmenues_(3u) @@ -74,7 +82,10 @@ class ResumptionDataTest : public ::testing::Test { , comlock_ptr_(std::make_shared<sync_primitives::Lock>()) , setlock_ptr_(std::make_shared<sync_primitives::Lock>()) , btnlock_ptr_(std::make_shared<sync_primitives::Lock>()) - , ivilock_ptr_(std::make_shared<sync_primitives::Lock>()) {} + , ivilock_ptr_(std::make_shared<sync_primitives::Lock>()) + , window_params_map_lock_ptr_(std::make_shared<sync_primitives::Lock>()) { + } + virtual ~ResumptionDataTest(); // Check structure in saved application void CheckSavedApp(sm::SmartObject& saved_data); // Set data for resumption @@ -114,6 +125,9 @@ class ResumptionDataTest : public ::testing::Test { void SetHelpAndTimeoutPrompt(); void SetVRHelpTitle(); void SetSubscriptions(); + void SetWindowsInfo(); + void SetDefaultCurrentHmiState(); + void SetDefaultWindowIds(); void CheckCommands(sm::SmartObject& res_list); void CheckGlobalProporties(sm::SmartObject& res_list); @@ -129,6 +143,7 @@ class ResumptionDataTest : public ::testing::Test { ns_smart_device_link::ns_smart_objects::SmartObject& res_list); void CheckVRTitle(sm::SmartObject& res_list); void CheckSubscriptions(sm::SmartObject& res_list); + void CheckWindowsInfo(sm::SmartObject& res_list); const size_t kCountOfCommands_; const size_t kCountOfChoice_; @@ -145,14 +160,18 @@ class ResumptionDataTest : public ::testing::Test { am::ButtonSubscriptions btn_subscr; + am::WindowParamsMap test_window_params_map_; + std::shared_ptr<sync_primitives::Lock> sublock_ptr_; std::shared_ptr<sync_primitives::Lock> comlock_ptr_; std::shared_ptr<sync_primitives::Lock> setlock_ptr_; std::shared_ptr<sync_primitives::Lock> btnlock_ptr_; std::shared_ptr<sync_primitives::Lock> ivilock_ptr_; + std::shared_ptr<sync_primitives::Lock> window_params_map_lock_ptr_; application_manager_test::MockApplicationManagerSettings mock_application_manager_settings_; - application_manager_test::MockApplicationManager mock_application_manager_; + NiceMock<application_manager_test::MockApplicationManager> + mock_application_manager_; std::shared_ptr<NiceMock<application_manager_test::MockAppExtension> > mock_app_extension_; std::list<application_manager::AppExtensionPtr> extensions_; diff --git a/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h index 3f5802cb5a..e7a8f25261 100644 --- a/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h +++ b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h @@ -44,13 +44,16 @@ namespace test { namespace components { namespace resumption_test { +using ::testing::NiceMock; + class TestResumptionDataDB : public ResumptionDataDB { public: utils::dbms::SQLDatabase* get_db_handle() { return db(); } - application_manager_test::MockApplicationManager mock_application_manager_; + NiceMock<application_manager_test::MockApplicationManager> + mock_application_manager_; TestResumptionDataDB(DbStorage db_storage) : ResumptionDataDB(db_storage, mock_application_manager_) {} }; |