/* * Copyright (c) 2015, 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 "gmock/gmock.h" #include "utils/macro.h" #include "application_manager/event_engine/event_dispatcher.h" #include "application_manager/mock_application.h" #include "application_manager/mock_application_manager.h" #include "application_manager/mock_application_manager_settings.h" #include "application_manager/mock_help_prompt_manager.h" #include "application_manager/mock_rpc_service.h" #include "application_manager/policies/policy_handler.h" #include "application_manager/resumption/resume_ctrl.h" #include "application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h" #include "application_manager/state_controller.h" #include "policy/mock_policy_settings.h" #include "smart_objects/enum_schema_item.h" #include "utils/custom_string.h" #include "utils/lock.h" #include "application_manager/commands/command_impl.h" #include "policy/policy_table/types.h" #include "rpc_base/rpc_base_json_inl.h" #ifdef EXTERNAL_PROPRIETARY_MODE #include "policy/policy_external/include/policy/policy_types.h" #endif namespace test { namespace components { namespace application_manager_test { namespace HmiLanguage = hmi_apis::Common_Language; namespace HmiResults = hmi_apis::Common_Result; namespace MobileResults = mobile_apis::Result; using namespace application_manager; typedef std::shared_ptr MockApplicationSharedPtr; typedef std::vector StringArray; typedef std::shared_ptr ApplicationSharedPtr; using testing::_; using testing::AtLeast; using testing::Return; using testing::ReturnRef; using testing::ReturnRefOfCopy; using testing::SaveArg; namespace { const uint32_t kAppId = 123u; const uint32_t kCorrelationId_ = 1939u; } // namespace TEST(MessageHelperTestCreate, CreateBlockedByPoliciesResponse_SmartObject_Equal) { mobile_apis::FunctionID::eType function_id = mobile_apis::FunctionID::eType::AddCommandID; mobile_apis::Result::eType result = mobile_apis::Result::eType::ABORTED; uint32_t correlation_id = 0; uint32_t connection_key = 0; bool success = false; smart_objects::SmartObjectSPtr ptr = application_manager::MessageHelper::CreateBlockedByPoliciesResponse( function_id, result, correlation_id, connection_key); EXPECT_TRUE((bool)ptr); smart_objects::SmartObject& obj = *ptr; EXPECT_EQ(function_id, obj[strings::params][strings::function_id].asInt()); EXPECT_EQ(kResponse, obj[strings::params][strings::message_type].asInt()); EXPECT_EQ(success, obj[strings::msg_params][strings::success].asBool()); EXPECT_EQ(result, obj[strings::msg_params][strings::result_code].asInt()); EXPECT_EQ(correlation_id, obj[strings::params][strings::correlation_id].asUInt()); EXPECT_EQ(connection_key, obj[strings::params][strings::connection_key].asUInt()); EXPECT_EQ(protocol_handler::MajorProtocolVersion::PROTOCOL_VERSION_2, obj[strings::params][strings::protocol_version].asInt()); } TEST(MessageHelperTestCreate, CreateSetAppIcon_SendNullPathImagetype_Equal) { std::string path_to_icon = ""; uint32_t app_id = 0; smart_objects::SmartObjectSPtr ptr = MessageHelper::CreateSetAppIcon(path_to_icon, app_id); EXPECT_TRUE((bool)ptr); smart_objects::SmartObject& obj = *ptr; int image_type = static_cast(mobile_api::ImageType::DYNAMIC); EXPECT_EQ(path_to_icon, obj[strings::sync_file_name][strings::value].asString()); EXPECT_EQ(image_type, obj[strings::sync_file_name][strings::image_type].asInt()); EXPECT_EQ(app_id, obj[strings::app_id].asUInt()); } TEST(MessageHelperTestCreate, CreateSetAppIcon_SendPathImagetype_Equal) { std::string path_to_icon = "/qwe/qwe/"; uint32_t app_id = 10; smart_objects::SmartObjectSPtr ptr = MessageHelper::CreateSetAppIcon(path_to_icon, app_id); EXPECT_TRUE((bool)ptr); smart_objects::SmartObject& obj = *ptr; int image_type = static_cast(mobile_api::ImageType::DYNAMIC); EXPECT_EQ(path_to_icon, obj[strings::sync_file_name][strings::value].asString()); EXPECT_EQ(image_type, obj[strings::sync_file_name][strings::image_type].asInt()); EXPECT_EQ(app_id, obj[strings::app_id].asUInt()); } TEST(MessageHelperTestCreate, CreateGlobalPropertiesRequestsToHMI_SmartObject_EmptyList) { MockApplicationSharedPtr appSharedMock = std::make_shared(); smart_objects::SmartObjectSPtr emptyObject = std::shared_ptr(); EXPECT_CALL(*appSharedMock, vr_help_title()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, vr_help()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, help_prompt()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, timeout_prompt()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, menu_title()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, menu_icon()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, menu_layout()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); EXPECT_CALL(*appSharedMock, keyboard_props()) .Times(AtLeast(1)) .WillOnce(Return(emptyObject)); std::shared_ptr mock_help_prompt_manager = std::make_shared(); EXPECT_CALL(*appSharedMock, help_prompt_manager()) .WillRepeatedly(ReturnRef(*mock_help_prompt_manager)); EXPECT_CALL(*mock_help_prompt_manager, GetSendingType()) .WillRepeatedly(Return(HelpPromptManager::SendingType::kSendBoth)); smart_objects::SmartObject user_loc = smart_objects::SmartObject(smart_objects::SmartType_Map); EXPECT_CALL(*appSharedMock, get_user_location()) .WillRepeatedly(ReturnRef(user_loc)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateGlobalPropertiesRequestsToHMI( appSharedMock, mock_application_manager); EXPECT_TRUE(ptr.empty()); } TEST(MessageHelperTestCreate, CreateGlobalPropertiesRequestsToHMI_SmartObject_NotEmpty) { MockApplicationSharedPtr appSharedMock = std::make_shared(); smart_objects::SmartObjectSPtr vrHelpTitle = std::make_shared("111"); smart_objects::SmartObjectSPtr vrHelp = std::make_shared("222"); smart_objects::SmartObjectSPtr keyboardProperties = std::make_shared("333"); smart_objects::SmartObjectSPtr menuTitle = std::make_shared("444"); smart_objects::SmartObjectSPtr menuIcon = std::make_shared("555"); smart_objects::SmartObjectSPtr helpPrompt = std::make_shared("666"); smart_objects::SmartObjectSPtr timeoutPrompt = std::make_shared("777"); smart_objects::SmartObjectSPtr menuLayout = std::make_shared("888"); smart_objects::SmartObject user_loc = smart_objects::SmartObject(smart_objects::SmartType_Map); user_loc[rc_rpc_plugin::strings::kGrid] = "[]"; EXPECT_CALL(*appSharedMock, vr_help_title()) .Times(AtLeast(3)) .WillRepeatedly(Return(vrHelpTitle)); EXPECT_CALL(*appSharedMock, vr_help()) .Times(AtLeast(2)) .WillRepeatedly(Return(vrHelp)); EXPECT_CALL(*appSharedMock, help_prompt()) .Times(AtLeast(3)) .WillRepeatedly(Return(helpPrompt)); EXPECT_CALL(*appSharedMock, timeout_prompt()) .Times(AtLeast(2)) .WillRepeatedly(Return(timeoutPrompt)); EXPECT_CALL(*appSharedMock, keyboard_props()) .Times(AtLeast(2)) .WillRepeatedly(Return(keyboardProperties)); EXPECT_CALL(*appSharedMock, menu_title()) .Times(AtLeast(2)) .WillRepeatedly(Return(menuTitle)); EXPECT_CALL(*appSharedMock, menu_icon()) .Times(AtLeast(2)) .WillRepeatedly(Return(menuIcon)); EXPECT_CALL(*appSharedMock, menu_layout()) .Times(AtLeast(2)) .WillRepeatedly(Return(menuLayout)); EXPECT_CALL(*appSharedMock, app_id()).WillRepeatedly(Return(0)); EXPECT_CALL(*appSharedMock, get_user_location()) .WillRepeatedly(ReturnRef(user_loc)); std::shared_ptr mock_help_prompt_manager = std::make_shared(); EXPECT_CALL(*appSharedMock, help_prompt_manager()) .WillRepeatedly(ReturnRef(*mock_help_prompt_manager)); EXPECT_CALL(*mock_help_prompt_manager, GetSendingType()) .WillRepeatedly(Return(HelpPromptManager::SendingType::kSendBoth)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateGlobalPropertiesRequestsToHMI( appSharedMock, mock_application_manager); EXPECT_FALSE(ptr.empty()); smart_objects::SmartObject& first = *ptr[0]; smart_objects::SmartObject& second = *ptr[1]; EXPECT_EQ(*vrHelpTitle, first[strings::msg_params][strings::vr_help_title]); EXPECT_EQ(*vrHelp, first[strings::msg_params][strings::vr_help]); EXPECT_EQ(*keyboardProperties, first[strings::msg_params][strings::keyboard_properties]); EXPECT_EQ(*menuTitle, first[strings::msg_params][strings::menu_title]); EXPECT_EQ(*menuIcon, first[strings::msg_params][strings::menu_icon]); EXPECT_EQ(*helpPrompt, second[strings::msg_params][strings::help_prompt]); EXPECT_EQ(*timeoutPrompt, second[strings::msg_params][strings::timeout_prompt]); EXPECT_EQ(*menuLayout, first[strings::msg_params][strings::menu_layout]); } TEST(MessageHelperTestCreate, CreateShowRequestToHMI_SendSmartObject_Equal) { MockApplicationSharedPtr appSharedMock = std::make_shared(); smart_objects::SmartObjectSPtr smartObjectPtr = std::make_shared(); EXPECT_CALL(*appSharedMock, show_command()) .Times(AtLeast(2)) .WillRepeatedly(Return(smartObjectPtr)); smart_objects::SmartObjectList ptr = MessageHelper::CreateShowRequestToHMI(appSharedMock, 0u); EXPECT_FALSE(ptr.empty()); smart_objects::SmartObject& obj = *ptr[0]; int function_id = static_cast(hmi_apis::FunctionID::UI_Show); EXPECT_EQ(function_id, obj[strings::params][strings::function_id].asInt()); EXPECT_EQ(*smartObjectPtr, obj[strings::msg_params]); } TEST(MessageHelperTestCreate, CreateAddCommandRequestToHMI_SendSmartObject_Empty) { MockApplicationSharedPtr appSharedMock = std::make_shared(); ::application_manager::CommandsMap vis; DataAccessor data_accessor( vis, std::make_shared()); EXPECT_CALL(*appSharedMock, commands_map()).WillOnce(Return(data_accessor)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddCommandRequestToHMI(appSharedMock, mock_application_manager); EXPECT_TRUE(ptr.empty()); } TEST(MessageHelperTestCreate, CreateAddCommandRequestToHMI_SendSmartObject_Equal) { MockApplicationSharedPtr appSharedMock = std::make_shared(); CommandsMap vis; DataAccessor data_accessor( vis, std::make_shared()); smart_objects::SmartObjectSPtr smartObjectPtr = std::make_shared(); smart_objects::SmartObject& object = *smartObjectPtr; const uint32_t app_id = 1u; const std::string cmd_icon_value = "10"; const uint32_t cmd_id = 5u; const uint32_t internal_id = 1u; object[strings::menu_params] = 1; object[strings::cmd_icon] = 1; object[strings::cmd_icon][strings::value] = cmd_icon_value; object[strings::cmd_id] = cmd_id; vis.insert( std::pair(internal_id, &object)); EXPECT_CALL(*appSharedMock, commands_map()).WillOnce(Return(data_accessor)); EXPECT_CALL(*appSharedMock, app_id()).WillOnce(Return(app_id)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddCommandRequestToHMI(appSharedMock, mock_application_manager); EXPECT_FALSE(ptr.empty()); smart_objects::SmartObject& obj = *ptr[0]; int function_id = static_cast(hmi_apis::FunctionID::UI_AddCommand); EXPECT_EQ(function_id, obj[strings::params][strings::function_id].asInt()); EXPECT_EQ(app_id, obj[strings::msg_params][strings::app_id].asUInt()); EXPECT_EQ(cmd_id, obj[strings::msg_params][strings::cmd_id].asUInt()); EXPECT_EQ(object[strings::menu_params], obj[strings::msg_params][strings::menu_params]); EXPECT_EQ(object[strings::cmd_icon], obj[strings::msg_params][strings::cmd_icon]); EXPECT_EQ( cmd_icon_value, obj[strings::msg_params][strings::cmd_icon][strings::value].asString()); } TEST(MessageHelperTestCreate, CreateAddVRCommandRequestFromChoiceToHMI_SendEmptyData_EmptyList) { MockApplicationSharedPtr appSharedMock = std::make_shared(); application_manager::ChoiceSetMap vis; DataAccessor< ::application_manager::ChoiceSetMap> data_accessor( vis, std::make_shared()); EXPECT_CALL(*appSharedMock, choice_set_map()).WillOnce(Return(data_accessor)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI( appSharedMock, mock_application_manager); EXPECT_TRUE(ptr.empty()); } TEST(MessageHelperTestCreate, CreateAddVRCommandRequestFromChoiceToHMI_SendObject_EqualList) { MockApplicationSharedPtr appSharedMock = std::make_shared(); application_manager::ChoiceSetMap vis; DataAccessor< ::application_manager::ChoiceSetMap> data_accessor( vis, std::make_shared()); smart_objects::SmartObjectSPtr smartObjectPtr = std::make_shared(); smart_objects::SmartObject& object = *smartObjectPtr; object[strings::choice_set] = "10"; object[strings::grammar_id] = 111; object[strings::choice_set][0][strings::choice_id] = 1; object[strings::choice_set][0][strings::vr_commands] = 2; vis.insert(std::pair(5, &object)); vis.insert(std::pair(6, &object)); vis.insert(std::pair(7, &object)); vis.insert(std::pair(8, &object)); vis.insert(std::pair(9, &object)); EXPECT_CALL(*appSharedMock, choice_set_map()).WillOnce(Return(data_accessor)); EXPECT_CALL(*appSharedMock, app_id()) .Times(AtLeast(5)) .WillRepeatedly(Return(1u)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI( appSharedMock, mock_application_manager); EXPECT_FALSE(ptr.empty()); int function_id = static_cast(hmi_apis::FunctionID::VR_AddCommand); int type = static_cast(hmi_apis::Common_VRCommandType::Choice); smart_objects::SmartObject& obj = *ptr[0]; EXPECT_EQ(function_id, obj[strings::params][strings::function_id].asInt()); EXPECT_EQ(1u, obj[strings::msg_params][strings::app_id].asUInt()); EXPECT_EQ(111u, obj[strings::msg_params][strings::grammar_id].asUInt()); EXPECT_EQ(object[strings::choice_set][0][strings::choice_id], obj[strings::msg_params][strings::cmd_id]); EXPECT_EQ(object[strings::choice_set][0][strings::vr_commands], obj[strings::msg_params][strings::vr_commands]); EXPECT_EQ(type, obj[strings::msg_params][strings::type].asInt()); } TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendObject_Equal) { MockApplicationSharedPtr appSharedMock = std::make_shared(); application_manager::SubMenuMap vis; DataAccessor< ::application_manager::SubMenuMap> data_accessor( vis, std::make_shared()); smart_objects::SmartObjectSPtr smartObjectPtr = std::make_shared(); smart_objects::SmartObject& object = *smartObjectPtr; object[strings::position] = 1; object[strings::menu_name] = 1; vis.insert(std::pair(5, &object)); EXPECT_CALL(*appSharedMock, sub_menu_map()).WillOnce(Return(data_accessor)); EXPECT_CALL(*appSharedMock, app_id()).Times(AtLeast(1)).WillOnce(Return(1u)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddSubMenuRequestsToHMI(appSharedMock, mock_application_manager); EXPECT_FALSE(ptr.empty()); smart_objects::SmartObject& obj = *ptr[0]; int function_id = static_cast(hmi_apis::FunctionID::UI_AddSubMenu); EXPECT_EQ(function_id, obj[strings::params][strings::function_id].asInt()); EXPECT_EQ(5, obj[strings::msg_params][strings::menu_id].asInt()); EXPECT_EQ(1, obj[strings::msg_params][strings::menu_params][strings::position] .asInt()); EXPECT_EQ(1, obj[strings::msg_params][strings::menu_params][strings::menu_name] .asInt()); EXPECT_EQ(1u, obj[strings::msg_params][strings::app_id].asUInt()); } TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendEmptyMap_EmptySmartObjectList) { MockApplicationSharedPtr appSharedMock = std::make_shared(); application_manager::SubMenuMap vis; DataAccessor< ::application_manager::SubMenuMap> data_accessor( vis, std::make_shared()); EXPECT_CALL(*appSharedMock, sub_menu_map()).WillOnce(Return(data_accessor)); application_manager_test::MockApplicationManager mock_application_manager; smart_objects::SmartObjectList ptr = MessageHelper::CreateAddSubMenuRequestsToHMI(appSharedMock, mock_application_manager); EXPECT_TRUE(ptr.empty()); } TEST(MessageHelperTestCreate, CreateNegativeResponse_SendSmartObject_Equal) { uint32_t connection_key = 111; int32_t function_id = 222; uint32_t correlation_id = 333u; int32_t result_code = 0; smart_objects::SmartObjectSPtr ptr = MessageHelper::CreateNegativeResponse( connection_key, function_id, correlation_id, result_code); EXPECT_TRUE((bool)ptr); smart_objects::SmartObject& obj = *ptr; int objFunction_id = obj[strings::params][strings::function_id].asInt(); uint32_t objCorrelation_id = obj[strings::params][strings::correlation_id].asUInt(); int objResult_code = obj[strings::msg_params][strings::result_code].asInt(); uint32_t objConnection_key = obj[strings::params][strings::connection_key].asUInt(); int message_type = static_cast(mobile_apis::messageType::response); int protocol_type = static_cast(commands::CommandImpl::mobile_protocol_type_); int protocol_version = static_cast(commands::CommandImpl::protocol_version_); bool success = false; EXPECT_EQ(function_id, objFunction_id); EXPECT_EQ(message_type, obj[strings::params][strings::message_type].asInt()); EXPECT_EQ(protocol_type, obj[strings::params][strings::protocol_type].asInt()); EXPECT_EQ(protocol_version, obj[strings::params][strings::protocol_version].asInt()); EXPECT_EQ(correlation_id, objCorrelation_id); EXPECT_EQ(result_code, objResult_code); EXPECT_EQ(success, obj[strings::msg_params][strings::success].asBool()); EXPECT_EQ(connection_key, objConnection_key); } class MessageHelperTest : public ::testing::Test { public: MessageHelperTest() : language_strings{"EN-US", "ES-MX", "FR-CA", "DE-DE", "ES-ES", "EN-GB", "RU-RU", "TR-TR", "PL-PL", "FR-FR", "IT-IT", "SV-SE", "PT-PT", "NL-NL", "EN-AU", "ZH-CN", "ZH-TW", "JA-JP", "AR-SA", "KO-KR", "PT-BR", "CS-CZ", "DA-DK", "NO-NO", "NL-BE", "EL-GR", "HU-HU", "FI-FI", "SK-SK", "EN-IN", "TH-TH", "EN-SA", "HE-IL", "RO-RO", "UK-UA", "ID-ID", "VI-VN", "MS-MY", "HI-IN"} , hmi_result_strings{"SUCCESS", "UNSUPPORTED_REQUEST", "UNSUPPORTED_RESOURCE", "DISALLOWED", "REJECTED", "ABORTED", "IGNORED", "RETRY", "IN_USE", "DATA_NOT_AVAILABLE", "TIMED_OUT", "INVALID_DATA", "CHAR_LIMIT_EXCEEDED", "INVALID_ID", "DUPLICATE_NAME", "APPLICATION_NOT_REGISTERED", "WRONG_LANGUAGE", "OUT_OF_MEMORY", "TOO_MANY_PENDING_REQUESTS", "NO_APPS_REGISTERED", "NO_DEVICES_CONNECTED", "WARNINGS", "GENERIC_ERROR", "USER_DISALLOWED", "TRUNCATED_DATA"} , mobile_result_strings{"SUCCESS", "UNSUPPORTED_REQUEST", "UNSUPPORTED_RESOURCE", "DISALLOWED", "REJECTED", "ABORTED", "IGNORED", "RETRY", "IN_USE", "VEHICLE_DATA_NOT_AVAILABLE", "TIMED_OUT", "INVALID_DATA", "CHAR_LIMIT_EXCEEDED", "INVALID_ID", "DUPLICATE_NAME", "APPLICATION_NOT_REGISTERED", "WRONG_LANGUAGE", "OUT_OF_MEMORY", "TOO_MANY_PENDING_REQUESTS", "TOO_MANY_APPLICATIONS", "APPLICATION_REGISTERED_ALREADY", "WARNINGS", "GENERIC_ERROR", "USER_DISALLOWED", "UNSUPPORTED_VERSION", "VEHICLE_DATA_NOT_ALLOWED", "FILE_NOT_FOUND", "CANCEL_ROUTE", "TRUNCATED_DATA", "SAVED", "INVALID_CERT", "EXPIRED_CERT", "RESUME_FAILED"} , function_id_strings{"RESERVED", "RegisterAppInterface", "UnregisterAppInterface", "SetGlobalProperties", "ResetGlobalProperties", "AddCommand", "DeleteCommand", "AddSubMenu", "DeleteSubMenu", "CreateInteractionChoiceSet", "PerformInteraction", "DeleteInteractionChoiceSet", "Alert", "Show", "Speak", "SetMediaClockTimer", "PerformAudioPassThru", "EndAudioPassThru", "SubscribeButton", "UnsubscribeButton", "SubscribeVehicleData", "UnsubscribeVehicleData", "GetVehicleData", "ReadDID", "GetDTCs", "ScrollableMessage", "Slider", "ShowConstantTBT", "AlertManeuver", "UpdateTurnList", "ChangeRegistration", "GenericResponse", "PutFile", "DeleteFile", "ListFiles", "SetAppIcon", "SetDisplayLayout", "DiagnosticMessage", "SystemRequest", "SendLocation", "DialNumber"} , events_id_strings{"OnHMIStatus", "OnAppInterfaceUnregistered", "OnButtonEvent", "OnButtonPress", "OnVehicleData", "OnCommand", "OnTBTClientState", "OnDriverDistraction", "OnPermissionsChange", "OnAudioPassThru", "OnLanguageChange", "OnKeyboardInput", "OnTouchEvent", "OnSystemRequest", "OnHashChange"} , hmi_level_strings{"FULL", "LIMITED", "BACKGROUND", "NONE"} , delta_from_functions_id(32768) {} void StartStreamPreConditions() { ON_CALL(mock_application_manager_, GetNextHMICorrelationID()) .WillByDefault(Return(kCorrelationId_)); ON_CALL(mock_application_manager_, get_settings()) .WillByDefault(ReturnRef(mock_app_mngr_settings_)); ON_CALL(mock_application_manager_, GetRPCService()) .WillByDefault(ReturnRef(mock_rpc_service_)); } protected: testing::NiceMock mock_application_manager_; testing::NiceMock mock_app_mngr_settings_; testing::NiceMock mock_rpc_service_; const StringArray language_strings; const StringArray hmi_result_strings; const StringArray mobile_result_strings; const StringArray function_id_strings; const StringArray events_id_strings; const StringArray hmi_level_strings; const size_t delta_from_functions_id; }; TEST_F(MessageHelperTest, ConvertEnumAPINoCheck_AnyEnumType_AnotherEnumType) { hmi_apis::Common_LayoutMode::eType tested_enum_value = hmi_apis::Common_LayoutMode::ICON_ONLY; hmi_apis::Common_AppHMIType::eType converted = MessageHelper::ConvertEnumAPINoCheck( tested_enum_value); EXPECT_EQ(hmi_apis::Common_AppHMIType::DEFAULT, converted); } TEST_F(MessageHelperTest, HMIToMobileResult_HmiResultEType_GetCorrectMobileResultEType) { MobileResults::eType tested_enum; HmiResults::eType casted_hmi_enum; MobileResults::eType converted_enum; // Check enums >=0 for (size_t enum_index = 0; enum_index < hmi_result_strings.size(); ++enum_index) { tested_enum = StringToEnum(hmi_result_strings[enum_index]); casted_hmi_enum = static_cast(enum_index); converted_enum = MessageHelper::HMIToMobileResult(casted_hmi_enum); EXPECT_EQ(tested_enum, converted_enum); } // Check invalid enums == -1 tested_enum = MobileResults::INVALID_ENUM; converted_enum = MessageHelper::HMIToMobileResult(HmiResults::INVALID_ENUM); EXPECT_EQ(tested_enum, converted_enum); // Check when out of range (true == result.empty()) casted_hmi_enum = static_cast(INT_MAX); converted_enum = MessageHelper::HMIToMobileResult(casted_hmi_enum); EXPECT_EQ(tested_enum, converted_enum); } TEST_F(MessageHelperTest, VerifySoftButtonString_WrongStrings_False) { const StringArray wrong_strings{"soft_button1\t\ntext", "soft_button1\\ntext", "soft_button1\\ttext", " ", "soft_button1\t\n", "soft_button1\\n", "soft_button1\\t"}; for (size_t i = 0; i < wrong_strings.size(); ++i) { EXPECT_FALSE(MessageHelper::VerifyString(wrong_strings[i])); } } TEST_F(MessageHelperTest, VerifySoftButtonString_CorrectStrings_True) { const StringArray wrong_strings{"soft_button1.text", "soft_button1?text", " asd asdasd .././/", "soft_button1??....asd", "soft_button12313fcvzxc./.,"}; for (size_t i = 0; i < wrong_strings.size(); ++i) { EXPECT_TRUE(MessageHelper::VerifyString(wrong_strings[i])); } } TEST_F(MessageHelperTest, ProcessSoftButtons_SmartObjectWithoutButtonsKey_Success) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject object; policy_handler_test::MockPolicySettings policy_settings_; const policy::PolicyHandler policy_handler(policy_settings_, mock_application_manager_); // Method call mobile_apis::Result::eType result = MessageHelper::ProcessSoftButtons( object, appSharedMock, policy_handler, mock_application_manager_); // Expect EXPECT_EQ(mobile_apis::Result::SUCCESS, result); } TEST_F(MessageHelperTest, ProcessSoftButtons_IncorectSoftButonValue_InvalidData) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject object; smart_objects::SmartObject& buttons = object[strings::soft_buttons]; // Setting invalid image string to button buttons[0][strings::image][strings::value] = "invalid\\nvalue"; policy_handler_test::MockPolicySettings policy_settings_; const policy::PolicyHandler policy_handler(policy_settings_, mock_application_manager_); // Method call mobile_apis::Result::eType result = MessageHelper::ProcessSoftButtons( object, appSharedMock, policy_handler, mock_application_manager_); // Expect EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result); } TEST_F(MessageHelperTest, VerifyImage_ImageTypeIsStatic_Success) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject image; image[strings::image_type] = mobile_apis::ImageType::STATIC; image[strings::value] = "static_icon"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImage( image, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::SUCCESS, result); } TEST_F(MessageHelperTest, VerifyImage_ImageValueNotValid_InvalidData) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject image; image[strings::image_type] = mobile_apis::ImageType::DYNAMIC; // Invalid value image[strings::value] = " "; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImage( image, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result); } TEST_F(MessageHelperTest, VerifyImageApplyPath_ImageTypeIsStatic_Success) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject image; image[strings::image_type] = mobile_apis::ImageType::STATIC; image[strings::value] = "icon.png"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImage( image, appSharedMock, mock_application_manager_); EXPECT_EQ(mobile_apis::Result::SUCCESS, result); // EXPECT EXPECT_EQ("icon.png", image[strings::value].asString()); } TEST_F(MessageHelperTest, VerifyImageApplyPath_ImageValueNotValid_InvalidData) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject image; image[strings::image_type] = mobile_apis::ImageType::DYNAMIC; // Invalid value image[strings::value] = " "; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImage( image, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result); } TEST_F(MessageHelperTest, VerifyImageFiles_SmartObjectWithValidData_Success) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject images; images[0][strings::image_type] = mobile_apis::ImageType::STATIC; images[1][strings::image_type] = mobile_apis::ImageType::STATIC; images[0][strings::value] = "static_icon"; images[1][strings::value] = "static_icon"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImageFiles( images, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::SUCCESS, result); } TEST_F(MessageHelperTest, VerifyImageFiles_SmartObjectWithInvalidData_NotSuccsess) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject images; images[0][strings::image_type] = mobile_apis::ImageType::DYNAMIC; images[1][strings::image_type] = mobile_apis::ImageType::DYNAMIC; // Invalid values images[0][strings::value] = " "; images[1][strings::value] = "image\\n"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImageFiles( images, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result); } TEST_F(MessageHelperTest, VerifyImageVrHelpItems_SmartObjectWithSeveralValidImages_Succsess) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject message; message[0][strings::image][strings::image_type] = mobile_apis::ImageType::STATIC; message[1][strings::image][strings::image_type] = mobile_apis::ImageType::STATIC; message[0][strings::image][strings::value] = "static_icon"; message[1][strings::image][strings::value] = "static_icon"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImageVrHelpItems( message, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::SUCCESS, result); } TEST_F(MessageHelperTest, VerifyImageVrHelpItems_SmartObjWithSeveralInvalidImages_NotSuccsess) { // Creating std::shared_ptr to MockApplication MockApplicationSharedPtr appSharedMock = std::make_shared(); // Creating input data for method smart_objects::SmartObject message; message[0][strings::image][strings::image_type] = mobile_apis::ImageType::DYNAMIC; message[1][strings::image][strings::image_type] = mobile_apis::ImageType::DYNAMIC; // Invalid values message[0][strings::image][strings::value] = " "; message[1][strings::image][strings::value] = "image\\n"; // Method call mobile_apis::Result::eType result = MessageHelper::VerifyImageVrHelpItems( message, appSharedMock, mock_application_manager_); // EXPECT EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result); } TEST_F(MessageHelperTest, StringifiedFunctionID_FinctionId_EqualsWithStringsInArray) { // Start from 1 because 1 == RESERVED and haven`t ID in last 2 characters // if FUNCTION ID == 1 inner DCHECK is false mobile_apis::FunctionID::eType casted_enum; std::string converted; for (size_t i = 1; i < function_id_strings.size(); ++i) { casted_enum = static_cast(i); converted = MessageHelper::StringifiedFunctionID(casted_enum); EXPECT_EQ(function_id_strings[i], converted); } // EventIDs emum strarts from delta_from_functions_id = 32768 for (size_t i = delta_from_functions_id; i < events_id_strings.size() + delta_from_functions_id; ++i) { casted_enum = static_cast(i); converted = MessageHelper::StringifiedFunctionID(casted_enum); EXPECT_EQ(events_id_strings[i - delta_from_functions_id], converted); } } TEST_F( MessageHelperTest, SubscribeApplicationToSoftButton_SoftbuttonsAreAbsent_DoesntCallFromApp) { MockApplicationSharedPtr appSharedPtr = std::make_shared(); smart_objects::SmartObject message_params; size_t function_id = 1; WindowSoftButtons window_buttons{ mobile_apis::PredefinedWindows::DEFAULT_WINDOW, {}}; EXPECT_CALL(*appSharedPtr, SubscribeToSoftButtons(function_id, window_buttons)) .Times(0); MessageHelper::SubscribeApplicationToSoftButton( message_params, appSharedPtr, function_id); } TEST_F(MessageHelperTest, SubscribeApplicationToSoftButton_SoftbuttonsExist_CallFromApp) { MockApplicationSharedPtr appSharedPtr = std::make_shared(); smart_objects::SmartObject message_params; message_params[strings::soft_buttons] = new smart_objects::SmartObject(smart_objects::SmartType_Array); const uint32_t softbutton1 = 1u; const uint32_t softbutton2 = 2u; const uint32_t softbutton3 = 3u; message_params[strings::soft_buttons][0][strings::soft_button_id] = softbutton1; message_params[strings::soft_buttons][1][strings::soft_button_id] = softbutton2; message_params[strings::soft_buttons][2][strings::soft_button_id] = softbutton3; size_t function_id = 1; WindowSoftButtons window_buttons{ mobile_apis::PredefinedWindows::DEFAULT_WINDOW, {softbutton1, softbutton2, softbutton3}}; EXPECT_CALL(*appSharedPtr, SubscribeToSoftButtons(function_id, window_buttons)); MessageHelper::SubscribeApplicationToSoftButton( message_params, appSharedPtr, function_id); } #ifdef EXTERNAL_PROPRIETARY_MODE TEST_F(MessageHelperTest, SendGetListOfPermissionsResponse_SUCCESS) { std::vector permissions; policy::ExternalConsentStatus external_consent_status; policy::FunctionalGroupPermission permission; permission.state = policy::GroupConsent::kGroupAllowed; permissions.push_back(permission); smart_objects::SmartObjectSPtr result; ON_CALL(mock_application_manager_, GetRPCService()) .WillByDefault(ReturnRef(mock_rpc_service_)); EXPECT_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillOnce(DoAll(SaveArg<0>(&result), Return(true))); const uint32_t correlation_id = 0u; MessageHelper::SendGetListOfPermissionsResponse(permissions, external_consent_status, correlation_id, mock_application_manager_, true); ASSERT_TRUE(result.get()); EXPECT_EQ(hmi_apis::FunctionID::SDL_GetListOfPermissions, (*result)[strings::params][strings::function_id].asInt()); smart_objects::SmartObject& msg_params = (*result)[strings::msg_params]; const std::string external_consent_status_key = "externalConsentStatus"; EXPECT_TRUE(msg_params.keyExists(external_consent_status_key)); EXPECT_TRUE(msg_params[external_consent_status_key].empty()); } TEST_F(MessageHelperTest, SendGetListOfPermissionsResponse_ExternalConsentStatusNonEmpty_SUCCESS) { std::vector permissions; policy::ExternalConsentStatus external_consent_status; const int32_t entity_type_1 = 1; const int32_t entity_id_1 = 2; const policy::EntityStatus entity_status_1 = policy::kStatusOn; const policy::EntityStatus entity_status_2 = policy::kStatusOff; const int32_t entity_type_2 = 3; const int32_t entity_id_2 = 4; external_consent_status.insert(policy::ExternalConsentStatusItem( entity_type_1, entity_id_1, entity_status_1)); external_consent_status.insert(policy::ExternalConsentStatusItem( entity_type_2, entity_id_2, entity_status_2)); smart_objects::SmartObjectSPtr result; ON_CALL(mock_application_manager_, GetRPCService()) .WillByDefault(ReturnRef(mock_rpc_service_)); EXPECT_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillOnce(DoAll(SaveArg<0>(&result), Return(true))); const uint32_t correlation_id = 0u; MessageHelper::SendGetListOfPermissionsResponse(permissions, external_consent_status, correlation_id, mock_application_manager_, true); ASSERT_TRUE(result.get()); smart_objects::SmartObject& msg_params = (*result)[strings::msg_params]; const std::string external_consent_status_key = "externalConsentStatus"; EXPECT_TRUE(msg_params.keyExists(external_consent_status_key)); smart_objects::SmartArray* status_array = msg_params[external_consent_status_key].asArray(); EXPECT_TRUE(external_consent_status.size() == status_array->size()); const std::string entityType = "entityType"; const std::string entityID = "entityID"; const std::string status = "status"; smart_objects::SmartObject item_1_so = smart_objects::SmartObject(smart_objects::SmartType_Map); item_1_so[entityType] = entity_type_1; item_1_so[entityID] = entity_id_1; item_1_so[status] = hmi_apis::Common_EntityStatus::ON; smart_objects::SmartObject item_2_so = smart_objects::SmartObject(smart_objects::SmartType_Map); item_2_so[entityType] = entity_type_2; item_2_so[entityID] = entity_id_2; item_2_so[status] = hmi_apis::Common_EntityStatus::OFF; EXPECT_TRUE(status_array->end() != std::find(status_array->begin(), status_array->end(), item_1_so)); EXPECT_TRUE(status_array->end() != std::find(status_array->begin(), status_array->end(), item_2_so)); } #endif TEST_F(MessageHelperTest, SendNaviSetVideoConfigRequest) { smart_objects::SmartObjectSPtr result; ON_CALL(mock_application_manager_, GetRPCService()) .WillByDefault(ReturnRef(mock_rpc_service_)); EXPECT_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillOnce(DoAll(SaveArg<0>(&result), Return(true))); int32_t app_id = 123; smart_objects::SmartObject video_params(smart_objects::SmartType_Map); video_params[strings::protocol] = hmi_apis::Common_VideoStreamingProtocol::RTP; video_params[strings::codec] = hmi_apis::Common_VideoStreamingCodec::H264; video_params[strings::width] = 640; video_params[strings::height] = 480; MessageHelper::SendNaviSetVideoConfig( app_id, mock_application_manager_, video_params); EXPECT_EQ(hmi_apis::FunctionID::Navigation_SetVideoConfig, (*result)[strings::params][strings::function_id].asInt()); smart_objects::SmartObject& msg_params = (*result)[strings::msg_params]; EXPECT_TRUE(msg_params.keyExists(strings::config)); EXPECT_TRUE(msg_params[strings::config].keyExists(strings::protocol)); EXPECT_EQ(1, msg_params[strings::config][strings::protocol].asInt()); EXPECT_TRUE(msg_params[strings::config].keyExists(strings::codec)); EXPECT_EQ(0, msg_params[strings::config][strings::codec].asInt()); EXPECT_TRUE(msg_params[strings::config].keyExists(strings::width)); EXPECT_EQ(640, msg_params[strings::config][strings::width].asInt()); EXPECT_TRUE(msg_params[strings::config].keyExists(strings::height)); EXPECT_EQ(480, msg_params[strings::config][strings::height].asInt()); } TEST_F(MessageHelperTest, SendAudioStartStream_SendAudioStreamUrl_MaxPath_Equal) { // baskslash-2 and place for a null character-1 auto const special_characters = 3; std::string audio_stream_file = "/"; audio_stream_file += std::string(PATH_MAX - NAME_MAX - special_characters, 'u') + "/"; audio_stream_file += std::string(NAME_MAX, 'u'); std::string audio_server_type; smart_objects::SmartObjectSPtr start_stream; StartStreamPreConditions(); ON_CALL(mock_app_mngr_settings_, audio_server_type()) .WillByDefault(ReturnRef(audio_server_type)); ON_CALL(mock_app_mngr_settings_, audio_stream_file()) .WillByDefault(ReturnRef(audio_stream_file)); ON_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillByDefault(DoAll(SaveArg<0>(&start_stream), Return(true))); MessageHelper::SendAudioStartStream(kAppId, mock_application_manager_); smart_objects::SmartObject& msg_params = (*start_stream)[strings::msg_params]; EXPECT_TRUE(msg_params.keyExists(strings::url)); EXPECT_EQ(msg_params[strings::url], audio_stream_file); } TEST_F(MessageHelperTest, SendAudioStartStream_SendAudioStreamUrl_ViolationOfLimits_NotEqual) { // baskslash-2 and place for a null character-1 auto const special_characters = 3; std::string audio_stream_file = "/"; audio_stream_file += std::string(PATH_MAX - NAME_MAX - special_characters, 'u') + "/"; audio_stream_file += std::string(NAME_MAX + 1, 'u'); std::string audio_server_type; smart_objects::SmartObjectSPtr start_stream; StartStreamPreConditions(); ON_CALL(mock_app_mngr_settings_, audio_server_type()) .WillByDefault(ReturnRef(audio_server_type)); ON_CALL(mock_app_mngr_settings_, audio_stream_file()) .WillByDefault(ReturnRef(audio_stream_file)); ON_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillByDefault(DoAll(SaveArg<0>(&start_stream), Return(true))); MessageHelper::SendAudioStartStream(kAppId, mock_application_manager_); smart_objects::SmartObject& msg_params = (*start_stream)[strings::msg_params]; EXPECT_TRUE(msg_params.keyExists(strings::url)); EXPECT_STRNE(msg_params[strings::url].asCharArray(), audio_stream_file.c_str()); } TEST_F(MessageHelperTest, SendNaviStartStream_SendVideoStreamUrl_MaxPath_Equal) { // baskslash-2 and place for a null character-1 auto const special_characters = 3; std::string video_stream_file = "/"; video_stream_file += std::string(PATH_MAX - NAME_MAX - special_characters, 'u') + "/"; video_stream_file += std::string(NAME_MAX, 'u'); std::string video_server_type; smart_objects::SmartObjectSPtr start_stream; StartStreamPreConditions(); ON_CALL(mock_app_mngr_settings_, video_server_type()) .WillByDefault(ReturnRef(video_server_type)); ON_CALL(mock_app_mngr_settings_, video_stream_file()) .WillByDefault(ReturnRef(video_stream_file)); ON_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillByDefault(DoAll(SaveArg<0>(&start_stream), Return(true))); MessageHelper::SendNaviStartStream(kAppId, mock_application_manager_); smart_objects::SmartObject& msg_params = (*start_stream)[strings::msg_params]; EXPECT_TRUE(msg_params.keyExists(strings::url)); EXPECT_EQ(msg_params[strings::url], video_stream_file); } TEST_F(MessageHelperTest, SendNaviStartStream_SendVideoStreamUrl_ViolationOfLimits_NotEqual) { // baskslash-2 and place for a null character-1 auto const special_characters = 3; std::string video_stream_file = "/"; video_stream_file += std::string(PATH_MAX - NAME_MAX - special_characters, 'u') + "/"; video_stream_file += std::string(NAME_MAX + 1, 'u'); std::string video_server_type; smart_objects::SmartObjectSPtr start_stream; StartStreamPreConditions(); ON_CALL(mock_app_mngr_settings_, video_server_type()) .WillByDefault(ReturnRef(video_server_type)); ON_CALL(mock_app_mngr_settings_, video_stream_file()) .WillByDefault(ReturnRef(video_stream_file)); ON_CALL(mock_rpc_service_, ManageHMICommand(_, _)) .WillByDefault(DoAll(SaveArg<0>(&start_stream), Return(true))); MessageHelper::SendNaviStartStream(kAppId, mock_application_manager_); smart_objects::SmartObject& msg_params = (*start_stream)[strings::msg_params]; EXPECT_TRUE(msg_params.keyExists(strings::url)); EXPECT_STRNE(msg_params[strings::url].asCharArray(), video_stream_file.c_str()); } TEST_F(MessageHelperTest, ExtractWindowIdFromSmartObject_SUCCESS) { const WindowID window_id = 145; smart_objects::SmartObject message(smart_objects::SmartType_Map); message[strings::msg_params][strings::window_id] = window_id; EXPECT_EQ(window_id, MessageHelper::ExtractWindowIdFromSmartObject( message[strings::msg_params])); } TEST_F(MessageHelperTest, ExtractWindowIdFromSmartObject_FromEmptyMessage) { smart_objects::SmartObject message(smart_objects::SmartType_Map); EXPECT_EQ(mobile_apis::PredefinedWindows::DEFAULT_WINDOW, MessageHelper::ExtractWindowIdFromSmartObject(message)); } TEST_F(MessageHelperTest, ExtractWindowIdFromSmartObject_FromWrongType) { smart_objects::SmartObject message(smart_objects::SmartType_Array); EXPECT_EQ(mobile_apis::PredefinedWindows::DEFAULT_WINDOW, MessageHelper::ExtractWindowIdFromSmartObject(message)); } TEST_F(MessageHelperTest, VehicleDataMapping_ContainsGeneratedVehicleTypes_SUCCESS) { using VehicleDataTypeEnum = mobile_apis::VehicleDataType::eType; using VehicleDataTypes = smart_objects::EnumConversionHelper; const auto& vehicle_data_mapping = MessageHelper::vehicle_data(); const auto& enum_map = VehicleDataTypes::enum_to_cstring_map(); // Values which vehicle_data_mapping doesn't contain const std::vector excluded_values = { VehicleDataTypeEnum::INVALID_ENUM, VehicleDataTypeEnum::VEHICLEDATA_OEM_CUSTOM_DATA, VehicleDataTypeEnum::VEHICLEDATA_BATTVOLTAGE}; for (const auto& enum_item : enum_map) { const auto& excluded_value = std::find( excluded_values.begin(), excluded_values.end(), enum_item.first); if (excluded_value != excluded_values.end()) { continue; } const auto& found_value = std::find_if( vehicle_data_mapping.begin(), vehicle_data_mapping.end(), [&enum_item](const std::pair& item) -> bool { return enum_item.first == item.second; }); EXPECT_NE(found_value, vehicle_data_mapping.end()); } } } // namespace application_manager_test } // namespace components } // namespace test