diff options
Diffstat (limited to 'src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h')
| -rw-r--r-- | src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h | 292 |
1 files changed, 292 insertions, 0 deletions
diff --git a/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h b/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h new file mode 100644 index 0000000000..dbee738564 --- /dev/null +++ b/src/components/application_manager/test/mock/include/application_manager/application_manager_impl.h @@ -0,0 +1,292 @@ +/* + * Copyright (c) 2014, 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_INCLUDE_APPLICATION_MANAGER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_H_ +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +#include <stdint.h> +#include <vector> +#include <map> +#include <set> +#include "application_manager/hmi_command_factory.h" +#include "application_manager/application_manager.h" +#include "application_manager/hmi_capabilities.h" +#include "application_manager/message.h" +#include "application_manager/request_controller.h" +#include "application_manager/resume_ctrl.h" +#include "application_manager/vehicle_info_data.h" +#include "protocol_handler/protocol_observer.h" +#include "hmi_message_handler/hmi_message_observer.h" +#include "hmi_message_handler/hmi_message_sender.h" + +#include "media_manager/media_manager_impl.h" + +#include "connection_handler/connection_handler_observer.h" +#include "connection_handler/device.h" + +#include "formatters/CSmartFactory.hpp" + +#include "interfaces/HMI_API.h" +#include "interfaces/HMI_API_schema.h" +#include "interfaces/MOBILE_API_schema.h" + +#include "interfaces/v4_protocol_v1_2_no_extra.h" +#include "interfaces/v4_protocol_v1_2_no_extra_schema.h" +#ifdef TIME_TESTER +#include "time_metric_observer.h" +#endif // TIME_TESTER + +#include "utils/macro.h" +#include "utils/shared_ptr.h" +#include "utils/message_queue.h" +#include "utils/prioritized_queue.h" +#include "utils/threads/thread.h" +#include "utils/threads/message_loop_thread.h" +#include "utils/lock.h" +#include "utils/singleton.h" + +namespace application_manager { + enum VRTTSSessionChanging { + kVRSessionChanging = 0, + kTTSSessionChanging = 1 + }; + +namespace impl { + +struct MessageFromMobile: public utils::SharedPtr<Message> { + explicit MessageFromMobile(const utils::SharedPtr<Message>& message) + : utils::SharedPtr<Message>(message) { + } + // PrioritizedQueue requres this method to decide which priority to assign + size_t PriorityOrder() const { + return (*this)->Priority().OrderingValue(); + } +}; + +struct MessageToMobile: public utils::SharedPtr<Message> { + explicit MessageToMobile(const utils::SharedPtr<Message>& message, + bool final_message) + : utils::SharedPtr<Message>(message), + is_final(final_message) { + } + // PrioritizedQueue requres this method to decide which priority to assign + size_t PriorityOrder() const { + return (*this)->Priority().OrderingValue(); + } + // Signals if connection to mobile must be closed after sending this message + bool is_final; +}; + +struct MessageFromHmi: public utils::SharedPtr<Message> { + explicit MessageFromHmi(const utils::SharedPtr<Message>& message) + : utils::SharedPtr<Message>(message) { + } + // PrioritizedQueue requres this method to decide which priority to assign + size_t PriorityOrder() const { + return (*this)->Priority().OrderingValue(); + } +}; + +struct MessageToHmi: public utils::SharedPtr<Message> { + explicit MessageToHmi(const utils::SharedPtr<Message>& message) + : utils::SharedPtr<Message>(message) { + } + // PrioritizedQueue requres this method to decide which priority to assign + size_t PriorityOrder() const { + return (*this)->Priority().OrderingValue(); + } +}; + +typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromMobile> > FromMobileQueue; +typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToMobile> > ToMobileQueue; +typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromHmi> > FromHmiQueue; +typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToHmi> > ToHmiQueue; + +} +typedef std::vector<std::string> RPCParams; + +class ApplicationManagerImpl : public ApplicationManager, + public hmi_message_handler::HMIMessageObserver, + public protocol_handler::ProtocolObserver, + public connection_handler::ConnectionHandlerObserver, + public impl::FromMobileQueue::Handler, public impl::ToMobileQueue::Handler, + public impl::FromHmiQueue::Handler, public impl::ToHmiQueue::Handler, + public utils::Singleton<ApplicationManagerImpl> { + + friend class ResumeCtrl; + friend class CommandImpl; + + public: + ApplicationManagerImpl() { + std::cout << "ApplicationManagerImpl Mock created " << std::endl; + } + + MOCK_METHOD0(Init, bool()); + MOCK_METHOD0(Stop, bool()); + MOCK_METHOD1(OnMessageReceived, void (utils::SharedPtr<application_manager::Message>)); + MOCK_METHOD1(OnErrorSending, void (utils::SharedPtr<application_manager::Message>)); + MOCK_METHOD1(OnMessageReceived, void (const RawMessagePtr)); + MOCK_METHOD1(OnMobileMessageSent, void (const RawMessagePtr)); + MOCK_METHOD1(OnDeviceListUpdated, void (const connection_handler::DeviceMap&)); + MOCK_METHOD0(OnFindNewApplicationsRequest, void ()); + MOCK_METHOD1(RemoveDevice, void (const connection_handler::DeviceHandle&)); + MOCK_METHOD3(OnServiceStartedCallback, bool (const connection_handler::DeviceHandle&, + const int32_t&, + const protocol_handler::ServiceType&)); + MOCK_METHOD2(OnServiceEndedCallback, void (const int32_t&, + const protocol_handler::ServiceType&)); + MOCK_METHOD1(Handle, void (const impl::MessageFromMobile)); + MOCK_METHOD1(Handle, void (const impl::MessageToMobile)); + MOCK_METHOD1(Handle, void (const impl::MessageFromHmi)); + MOCK_METHOD1(Handle, void (const impl::MessageToHmi)); + + //ApplicationManager methods + MOCK_METHOD1(set_hmi_message_handler, void (hmi_message_handler::HMIMessageHandler*)); + MOCK_METHOD1(set_protocol_handler, void (protocol_handler::ProtocolHandler*)); + MOCK_METHOD1(set_connection_handler, void (connection_handler::ConnectionHandler*)); + + //ApplicationManagerImpl methods: + + MOCK_METHOD1(SetTimeMetricObserver, void(AMMetricObserver*)); + MOCK_METHOD1(RegisterApplication, + ApplicationSharedPtr(const utils::SharedPtr<smart_objects::SmartObject>&)); + MOCK_METHOD0(hmi_capabilities, HMICapabilities& ()); + MOCK_METHOD1(ManageHMICommand, bool (const utils::SharedPtr<smart_objects::SmartObject>&)); + MOCK_METHOD1(ManageMobileCommand, bool (const utils::SharedPtr<smart_objects::SmartObject>& message)); + MOCK_METHOD1(SendMessageToHMI, bool (const utils::SharedPtr<smart_objects::SmartObject>&)); + MOCK_METHOD2(SendMessageToMobile, bool (const utils::SharedPtr<smart_objects::SmartObject>&, + bool)); + MOCK_METHOD1(SendMessageToMobile, bool (const utils::SharedPtr<smart_objects::SmartObject>&)); + MOCK_METHOD1(GetDeviceName, std::string (connection_handler::DeviceHandle)); + MOCK_METHOD1(application, ApplicationSharedPtr (uint32_t)); + MOCK_METHOD1(application_by_policy_id, ApplicationSharedPtr (const std::string&)); + MOCK_METHOD1(RemoveAppDataFromHMI, bool(ApplicationSharedPtr)); + MOCK_METHOD1(HeadUnitReset, void(mobile_api::AppInterfaceUnregisteredReason::eType)); + MOCK_METHOD0(HeadUnitSuspend, void()); + MOCK_METHOD1(LoadAppDataToHMI, bool(ApplicationSharedPtr)); + MOCK_METHOD1(ActivateApplication, bool (ApplicationSharedPtr)); + MOCK_METHOD1(PutApplicationInLimited, mobile_api::HMILevel::eType (ApplicationSharedPtr)); + MOCK_METHOD1(PutApplicationInFull, mobile_api::HMILevel::eType (ApplicationSharedPtr)); + MOCK_METHOD2(UnregisterRevokedApplication, void(uint32_t, mobile_apis::Result::eType)); + MOCK_METHOD1(SetUnregisterAllApplicationsReason, void(mobile_api::AppInterfaceUnregisteredReason::eType)); + MOCK_METHOD1(UnregisterAllApplications, void(bool)); + MOCK_METHOD0(connection_handler, connection_handler::ConnectionHandler*()); + MOCK_METHOD0(protocol_handler, protocol_handler::ProtocolHandler*()); + MOCK_METHOD0(hmi_message_handler, hmi_message_handler::HMIMessageHandler*()); + MOCK_METHOD5(CheckPolicyPermissions, mobile_apis::Result::eType(const std::string&, + mobile_apis::HMILevel::eType, + mobile_apis::FunctionID::eType, + const RPCParams&, + CommandParametersPermissions*)); + MOCK_METHOD3(updateRequestTimeout, void(uint32_t, uint32_t, uint32_t)); + MOCK_METHOD0(GenerateGrammarID, uint32_t()); + MOCK_METHOD0(GenerateNewHMIAppID, uint32_t()); + MOCK_METHOD1(GetAvailableSpaceForApp, uint32_t(const std::string&)); + MOCK_METHOD0(begin_audio_pass_thru, bool ()); + MOCK_METHOD0(end_audio_pass_thru, uint32_t()); + MOCK_METHOD1(StopAudioPassThru, void(uint32_t)); + MOCK_METHOD1(applications_by_button, std::vector<ApplicationSharedPtr>(uint32_t)); + MOCK_METHOD0(applications_with_navi, std::vector<ApplicationSharedPtr>()); + MOCK_METHOD1(applications_by_ivi, std::vector<ApplicationSharedPtr>(uint32_t)); + MOCK_METHOD2(IviInfoUpdated, std::vector<utils::SharedPtr<Application>> (VehicleDataType, + int)); + MOCK_METHOD6(StartAudioPassThruThread, void(uint32_t, uint32_t, uint32_t, + uint32_t, uint32_t, uint32_t)); + MOCK_METHOD4(SaveBinary, mobile_apis::Result::eType(const std::vector<uint8_t>&, + const std::string&, + const std::string&, + const int64_t)); + MOCK_METHOD1(ReplaceHMIByMobileAppId, void(smart_objects::SmartObject&)); + MOCK_METHOD1(ReplaceMobileByHMIAppId, void(smart_objects::SmartObject&)); + MOCK_METHOD0(resume_controller, ResumeCtrl&()); + MOCK_METHOD1(IsVideoStreamingAllowed, bool(uint32_t)); + MOCK_METHOD1(IsAudioStreamingAllowed, bool(uint32_t)); + MOCK_METHOD1(Unmute, void(VRTTSSessionChanging)); + MOCK_METHOD1(Mute, void(VRTTSSessionChanging)); + MOCK_METHOD2(set_application_id, void(const int32_t, const uint32_t)); + MOCK_METHOD1(application_id, uint32_t(const int32_t)); + MOCK_METHOD1(removeNotification, void(const commands::Command*)); + MOCK_METHOD1(addNotification, void(const CommandSharedPtr )); + MOCK_METHOD0(StartDevicesDiscovery, void()); + MOCK_METHOD2(SendAudioPassThroughNotification, void(uint32_t, std::vector<uint8_t>)); + MOCK_METHOD1(set_all_apps_allowed, void(const bool)); + MOCK_CONST_METHOD0(all_apps_allowed, bool()); + MOCK_METHOD1(set_vr_session_started, void(const bool)); + MOCK_CONST_METHOD0(vr_session_started, bool()); + MOCK_METHOD1(set_driver_distraction, void(const bool)); + MOCK_CONST_METHOD0(driver_distraction, bool()); + MOCK_METHOD1(ConnectToDevice, void(uint32_t)); + MOCK_METHOD0(OnHMIStartedCooperation, void()); + MOCK_METHOD0(GetNextHMICorrelationID, uint32_t ()); + MOCK_CONST_METHOD0(IsHMICooperating, bool()); + MOCK_METHOD0(OnTimerSendTTSGlobalProperties, void()); + MOCK_METHOD1(AddAppToTTSGlobalPropertiesList, void(const uint32_t)); + MOCK_METHOD1(RemoveAppFromTTSGlobalPropertiesList, void(const uint32_t)); + MOCK_METHOD1(application_by_hmi_app, ApplicationSharedPtr(uint32_t)); + MOCK_METHOD2(UnregisterApplication, void(const uint32_t,mobile_apis::Result::eType)); + MOCK_METHOD3(UnregisterApplication, void(const uint32_t,mobile_apis::Result::eType, + bool)); + MOCK_METHOD4(UnregisterApplication, void(const uint32_t,mobile_apis::Result::eType, + bool, bool)); + MOCK_CONST_METHOD0(active_application, ApplicationSharedPtr ()); + MOCK_METHOD0(OnApplicationListUpdateTimer, void()); + + typedef const std::set<ApplicationSharedPtr> TAppList; + typedef std::set<ApplicationSharedPtr>::iterator TAppListIt; + typedef std::set<ApplicationSharedPtr>::const_iterator TAppListConstIt; + class ApplicationListUpdateTimer : public timer::TimerThread<ApplicationManagerImpl> { + public: + ApplicationListUpdateTimer(ApplicationManagerImpl* callee) : + timer::TimerThread<ApplicationManagerImpl>("AM ListUpdater", + callee, &ApplicationManagerImpl::OnApplicationListUpdateTimer + ) { + } + }; + typedef utils::SharedPtr<ApplicationListUpdateTimer> ApplicationListUpdateTimerSptr; + + class ApplicationListAccessor { + public: + MOCK_METHOD0(applications, TAppList()); + private: + }; + friend class ApplicationListAccessor; + + private: + //FIXME(AKutsan) In resume_controller is is nessesery to change realisation for remove using application_list_ + std::set<ApplicationSharedPtr> application_list_; + FRIEND_BASE_SINGLETON_CLASS(ApplicationManagerImpl); +}; + +} //application_manager +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_H_ |