Cover Send methods from MessageHelper with Unit tests.

Added Unit tests for the SendOnAppUnregNotificationToHMI,
SendOnButtonSubscriptionNotification, SendOnDataStreaming,
SendOnPermissionsChangeNotification, SendOnResumeAudioSourceToHMI,
SendOnSDLConsentNeeded, SendOnStatusUpdate,
SendPolicySnapshotNotification, SendUnsubscribedWayPoints,
SendUpdateSDLResponse and SendOnPermissionsChangeNotification
methods of MessageHelper class.

Minor refactoring of MessageHelper and MessageHelper tests.

Fixed PrintSmartObject to use logger instead printf.

Fixed Windows build of MessageHelper test.

Related: APPLINK-25519

4 files changed, 781 insertions, 296 deletions

diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h
index 3c42ae742c..8f527c9ab2 100644
--- a/src/components/application_manager/include/application_manager/message_helper.h
+++ b/src/components/application_manager/include/application_manager/message_helper.h
@@ -101,7 +101,7 @@ class MessageHelper {
    * @brief Sends OnLanguageChange notification to application
    * @param connection_key Connection key of application
    */
-  static void SendOnLanguageChangeToMobile(uint32_t connection_key);
+  static void SendOnLanguageChangeToMobile(const uint32_t connection_key);
 
   /*
    * @brief Retrieve vehicle data map for param name in mobile request
@@ -117,7 +117,7 @@ class MessageHelper {
    * @return stringified value for enum if succedeed, otherwise - empty string
    */
   static std::string HMIResultToString(
-      hmi_apis::Common_Result::eType hmi_result);
+      const hmi_apis::Common_Result::eType hmi_result);
 
   /**
    * @brief Converts string to HMI Result enum value
@@ -134,7 +134,7 @@ class MessageHelper {
    * @return stringified value for enum if succedeed, otherwise - empty string
    */
   static std::string MobileResultToString(
-      mobile_apis::Result::eType mobile_result);
+      const mobile_apis::Result::eType mobile_result);
 
   /**
    * @brief Converts string to mobile Result enum value
@@ -177,20 +177,20 @@ class MessageHelper {
   * @param hmi_level Desired HMI Level
   */
   static std::string StringifiedHMILevel(
-      mobile_apis::HMILevel::eType hmi_level);
+      const mobile_apis::HMILevel::eType hmi_level);
 
   /*
   * @brief Used to obtain function name by its id
   * @param function_id Function ID
   */
   static std::string StringifiedFunctionID(
-      mobile_apis::FunctionID::eType function_id);
+      const mobile_apis::FunctionID::eType function_id);
 
   static smart_objects::SmartObjectSPtr CreateBlockedByPoliciesResponse(
-      mobile_apis::FunctionID::eType function_id,
-      mobile_apis::Result::eType result,
+      const mobile_apis::FunctionID::eType function_id,
+      const mobile_apis::Result::eType result,
       const uint32_t correlation_id,
-      uint32_t connection_key);
+      const uint32_t connection_key);
 
   /*
    * @brief Prepare GetDeviceListResponse
@@ -205,10 +205,10 @@ class MessageHelper {
       ApplicationManager& app_mngr);
 
   static smart_objects::SmartObjectSPtr CreateModuleInfoSO(
-      uint32_t function_id, ApplicationManager& app_mngr);
+      const uint32_t function_id, ApplicationManager& app_mngr);
 
   static smart_objects::SmartObjectSPtr CreateSetAppIcon(
-      const std::string& path_to_icon, uint32_t app_id);
+      const std::string& path_to_icon, const uint32_t app_id);
 
   /**
    * @brief Sends IVI subscription requests
@@ -272,13 +272,13 @@ class MessageHelper {
   static void SendChangeRegistrationRequestToHMI(ApplicationConstSharedPtr app,
                                                  ApplicationManager& app_mngr);
   static void SendAddVRCommandToHMI(
-      uint32_t cmd_id,
+      const uint32_t cmd_id,
       const smart_objects::SmartObject& vr_commands,
       const uint32_t app_id,
       ApplicationManager& app_mngr);
 
   static smart_objects::SmartObjectSPtr CreateAddVRCommandToHMI(
-      uint32_t cmd_id,
+      const uint32_t cmd_id,
       const smart_objects::SmartObject& vr_commands,
       const uint32_t app_id,
       ApplicationManager& app_mngr);
@@ -307,16 +307,17 @@ class MessageHelper {
    * @param is_unexpected_disconnect
    * Indicates if connection was unexpectedly lost by TM or HB
    */
-  static void SendOnAppUnregNotificationToHMI(ApplicationConstSharedPtr app,
-                                              bool is_unexpected_disconnect,
-                                              ApplicationManager& app_mngr);
+  static void SendOnAppUnregNotificationToHMI(
+      ApplicationConstSharedPtr app,
+      const bool is_unexpected_disconnect,
+      ApplicationManager& app_mngr);
 
   static NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr
   GetBCActivateAppRequestToHMI(
       ApplicationConstSharedPtr app,
       const protocol_handler::SessionObserver& session_observer,
       const policy::PolicyHandlerInterface& policy_handler,
-      hmi_apis::Common_HMILevel::eType level,
+      const hmi_apis::Common_HMILevel::eType level,
       bool send_policy_priority,
       ApplicationManager& app_mngr);
 
@@ -328,7 +329,7 @@ class MessageHelper {
   * @param permissions response parameters
   */
   static void SendSDLActivateAppResponse(policy::AppPermissions& permissions,
-                                         uint32_t correlation_id,
+                                         const uint32_t correlation_id,
                                          ApplicationManager& app_mngr);
 
   /**
@@ -346,7 +347,7 @@ class MessageHelper {
     * @param retries Seconds between retries
     */
   static void SendPolicyUpdate(const std::string& file_path,
-                               int timeout,
+                               const int timeout,
                                const std::vector<int>& retries,
                                ApplicationManager& app_mngr);
 
@@ -357,7 +358,7 @@ class MessageHelper {
    */
   static void SendGetUserFriendlyMessageResponse(
       const std::vector<policy::UserFriendlyMessage>& msg,
-      uint32_t correlation_id,
+      const uint32_t correlation_id,
       ApplicationManager& app_mngr);
 
   /**
@@ -367,7 +368,7 @@ class MessageHelper {
    */
   static void SendGetListOfPermissionsResponse(
       const std::vector<policy::FunctionalGroupPermission>& permissions,
-      uint32_t correlation_id,
+      const uint32_t correlation_id,
       ApplicationManager& app_mngr);
 
   /*
@@ -376,7 +377,8 @@ class MessageHelper {
    * @param connection_key  Application connection key
    *
    */
-  static void SendNaviStartStream(int32_t app_id, ApplicationManager& app_mngr);
+  static void SendNaviStartStream(const int32_t app_id,
+                                  ApplicationManager& app_mngr);
 
   /*
    * @brief Sends notification to HMI to stop video streaming
@@ -384,7 +386,8 @@ class MessageHelper {
    * @param connection_key  Application connection key
    *
    */
-  static void SendNaviStopStream(int32_t app_id, ApplicationManager& app_mngr);
+  static void SendNaviStopStream(const int32_t app_id,
+                                 ApplicationManager& app_mngr);
 
   /*
   * @brief Send notification for Update of Policy Table
@@ -395,13 +398,13 @@ class MessageHelper {
   * @param timeout If -1 no timeout is provdied
   */
   static void SendPolicySnapshotNotification(
-      uint32_t connection_key,
+      const uint32_t connection_key,
       const std::vector<uint8_t>& policy_data,
       const std::string& url,
       ApplicationManager& app_mngr);
 
   static void SendSystemRequestNotification(
-      uint32_t connection_key,
+      const uint32_t connection_key,
       NsSmartDeviceLink::NsSmartObjects::SmartObject& content,
       ApplicationManager& app_mngr);
 
@@ -432,7 +435,7 @@ class MessageHelper {
   * @param permissions updated permissions for application
   */
   static void SendOnPermissionsChangeNotification(
-      uint32_t connection_key,
+      const uint32_t connection_key,
       const policy::Permissions& permissions,
       ApplicationManager& app_mngr);
 
@@ -483,7 +486,7 @@ class MessageHelper {
    * @param connection_key  Application connection key
    *
    */
-  static void SendAudioStartStream(int32_t app_id,
+  static void SendAudioStartStream(const int32_t app_id,
                                    ApplicationManager& app_mngr);
 
   /*
@@ -492,11 +495,11 @@ class MessageHelper {
    * @param connection_key  Application connection key
    *
    */
-  static void SendAudioStopStream(int32_t connection_key,
+  static void SendAudioStopStream(const int32_t connection_key,
                                   ApplicationManager& app_mngr);
 
-  static void SendOnDataStreaming(protocol_handler::ServiceType service,
-                                  bool available,
+  static void SendOnDataStreaming(const protocol_handler::ServiceType service,
+                                  const bool available,
                                   ApplicationManager& app_mngr);
 
   /*
@@ -515,10 +518,10 @@ class MessageHelper {
   static bool SendUnsubscribedWayPoints(ApplicationManager& app_mngr);
 
   static smart_objects::SmartObjectSPtr CreateNegativeResponse(
-      uint32_t connection_key,
-      int32_t function_id,
+      const uint32_t connection_key,
+      const int32_t function_id,
       const uint32_t correlation_id,
-      int32_t result_code);
+      const int32_t result_code);
 
   /*
    * @brief Verify image and add image file full path
@@ -583,7 +586,7 @@ class MessageHelper {
   static void SubscribeApplicationToSoftButton(
       smart_objects::SmartObject& message_params,
       ApplicationSharedPtr app,
-      int32_t function_id);
+      const int32_t function_id);
 
   static bool PrintSmartObject(const smart_objects::SmartObject& object);
 
@@ -600,7 +603,7 @@ class MessageHelper {
    * @return Common language string representation
    */
   static std::string CommonLanguageToString(
-      hmi_apis::Common_Language::eType language);
+      const hmi_apis::Common_Language::eType language);
 
   /**
    * @brief Converts string to mobile language enum value
@@ -665,7 +668,7 @@ class MessageHelper {
       const std::string& language);
   static smart_objects::SmartObjectSPtr
   GetOnAppInterfaceUnregisteredNotificationToMobile(
-      int32_t connection_key,
+      const int32_t connection_key,
       mobile_api::AppInterfaceUnregisteredReason::eType reason);
 
  private:
diff --git a/src/components/application_manager/src/message_helper.cc b/src/components/application_manager/src/message_helper.cc
index 3070c1604b..f4a5f8b16a 100644
--- a/src/components/application_manager/src/message_helper.cc
+++ b/src/components/application_manager/src/message_helper.cc
@@ -232,7 +232,7 @@ const uint32_t MessageHelper::GetPriorityCode(const std::string& priority) {
 }
 
 std::string MessageHelper::CommonLanguageToString(
-    hmi_apis::Common_Language::eType language) {
+    const hmi_apis::Common_Language::eType language) {
   using namespace NsSmartDeviceLink::NsSmartObjects;
   const char* str = 0;
   if (EnumConversionHelper<hmi_apis::Common_Language::eType>::EnumToCString(
@@ -303,7 +303,7 @@ void MessageHelper::SendHashUpdateNotification(const uint32_t app_id,
 
 smart_objects::SmartObjectSPtr
 MessageHelper::GetOnAppInterfaceUnregisteredNotificationToMobile(
-    int32_t connection_key,
+    const int32_t connection_key,
     mobile_api::AppInterfaceUnregisteredReason::eType reason) {
   SDL_AUTO_TRACE();
 
@@ -329,7 +329,7 @@ const VehicleData& MessageHelper::vehicle_data() {
 }
 
 std::string MessageHelper::HMIResultToString(
-    hmi_apis::Common_Result::eType hmi_result) {
+    const hmi_apis::Common_Result::eType hmi_result) {
   using namespace NsSmartDeviceLink::NsSmartObjects;
   const char* str = 0;
   if (EnumConversionHelper<hmi_apis::Common_Result::eType>::EnumToCString(
@@ -351,7 +351,7 @@ hmi_apis::Common_Result::eType MessageHelper::HMIResultFromString(
 }
 
 std::string MessageHelper::MobileResultToString(
-    mobile_apis::Result::eType mobile_result) {
+    const mobile_apis::Result::eType mobile_result) {
   using namespace NsSmartDeviceLink::NsSmartObjects;
   const char* str = 0;
   if (EnumConversionHelper<mobile_apis::Result::eType>::EnumToCString(
@@ -402,7 +402,7 @@ mobile_apis::HMILevel::eType MessageHelper::StringToHMILevel(
 }
 
 std::string MessageHelper::StringifiedHMILevel(
-    mobile_apis::HMILevel::eType hmi_level) {
+    const mobile_apis::HMILevel::eType hmi_level) {
   using namespace NsSmartDeviceLink::NsSmartObjects;
   const char* str = 0;
   if (EnumConversionHelper<mobile_apis::HMILevel::eType>::EnumToCString(
@@ -413,7 +413,7 @@ std::string MessageHelper::StringifiedHMILevel(
 }
 
 std::string MessageHelper::StringifiedFunctionID(
-    mobile_apis::FunctionID::eType function_id) {
+    const mobile_apis::FunctionID::eType function_id) {
   SDL_AUTO_TRACE();
   using namespace NsSmartDeviceLink::NsSmartObjects;
   const char* str = 0;
@@ -506,7 +506,7 @@ void MessageHelper::CreateGetVehicleDataRequest(
 #ifdef HMI_DBUS_API
   for (std::vector<std::string>::const_iterator it = params.begin();
        it != params.end();
-       it++) {
+       ++it) {
     smart_objects::SmartObjectSPtr request =
         utils::MakeShared<smart_objects::SmartObject>();
 
@@ -546,10 +546,10 @@ void MessageHelper::CreateGetVehicleDataRequest(
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateBlockedByPoliciesResponse(
-    mobile_apis::FunctionID::eType function_id,
-    mobile_apis::Result::eType result,
+    const mobile_apis::FunctionID::eType function_id,
+    const mobile_apis::Result::eType result,
     const uint32_t correlation_id,
-    uint32_t connection_key) {
+    const uint32_t connection_key) {
   SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr response =
       utils::MakeShared<smart_objects::SmartObject>();
@@ -604,7 +604,7 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateDeviceListSO(
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateModuleInfoSO(
-    uint32_t function_id, ApplicationManager& app_mngr) {
+    const uint32_t function_id, ApplicationManager& app_mngr) {
   SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr module_info =
       utils::MakeShared<smart_objects::SmartObject>(
@@ -620,7 +620,7 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateModuleInfoSO(
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateSetAppIcon(
-    const std::string& path_to_icon, uint32_t app_id) {
+    const std::string& path_to_icon, const uint32_t app_id) {
   SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr set_icon =
       utils::MakeShared<smart_objects::SmartObject>(
@@ -714,9 +714,9 @@ smart_objects::SmartObjectList MessageHelper::GetIVISubscriptionRequests(
 }
 
 void MessageHelper::SendOnButtonSubscriptionNotification(
-    uint32_t app_id,
-    hmi_apis::Common_ButtonName::eType button,
-    bool is_subscribed,
+    const uint32_t app_id,
+    const hmi_apis::Common_ButtonName::eType button,
+    const bool is_subscribed,
     ApplicationManager& app_mngr) {
   using namespace smart_objects;
   using namespace hmi_apis;
@@ -1245,7 +1245,7 @@ void MessageHelper::SendAddVRCommandToHMI(
 smart_objects::SmartObjectSPtr MessageHelper::CreateAddVRCommandToHMI(
     const uint32_t cmd_id,
     const smart_objects::SmartObject& vr_commands,
-    uint32_t app_id,
+    const uint32_t app_id,
     ApplicationManager& app_mngr) {
   smart_objects::SmartObjectSPtr vr_command =
       CreateRequestObject(app_mngr.GetNextHMICorrelationID());
@@ -1390,32 +1390,44 @@ smart_objects::SmartObjectList MessageHelper::CreateAddSubMenuRequestToHMI(
 
 void MessageHelper::SendOnAppUnregNotificationToHMI(
     ApplicationConstSharedPtr app,
-    bool is_unexpected_disconnect,
+    const bool is_unexpected_disconnect,
     ApplicationManager& app_mngr) {
+  SDL_AUTO_TRACE();
+  if (!app.valid()) {
+    SDL_ERROR("Application is not valid");
+    return;
+  }
+
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
+  if (!notification) {
+    SDL_ERROR("Memory allocation for notification failed.");
+    return;
+  }
   smart_objects::SmartObject& message = *notification;
 
   message[strings::params][strings::function_id] =
       hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered;
 
   message[strings::params][strings::message_type] = MessageType::kNotification;
-  // we put hmi_app_id because applicaton list does not contain application on
-  // this momment
-  // and ReplaceHMIByMobileAppId function will be unable to replace app_id to
-  // hmi_app_id
+  // we put hmi_app_id because applicaton list does not contain application at
+  // this momment and ReplaceHMIByMobileAppId function will be unable to replace
+  // app_id to hmi_app_id
   message[strings::msg_params][strings::app_id] = app->hmi_app_id();
   message[strings::msg_params][strings::unexpected_disconnect] =
       is_unexpected_disconnect;
-  app_mngr.ManageHMICommand(notification);
+
+  if (!app_mngr.ManageHMICommand(notification)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
     ApplicationConstSharedPtr app,
     const protocol_handler::SessionObserver& session_observer,
     const policy::PolicyHandlerInterface& policy_handler,
-    hmi_apis::Common_HMILevel::eType level,
+    const hmi_apis::Common_HMILevel::eType level,
     bool send_policy_priority,
     ApplicationManager& app_mngr) {
   DCHECK_OR_RETURN(app, smart_objects::SmartObjectSPtr());
@@ -1459,7 +1471,8 @@ smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
 
 void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id,
                                                  ApplicationManager& app_mngr) {
-  SDL_WARN("SendOnResumeAudioSourceToHMI app_id: " << app_id);
+  SDL_AUTO_TRACE();
+  SDL_INFO("app_id: " << app_id);
   application_manager::ApplicationConstSharedPtr app =
       app_mngr.application(app_id);
   if (!app) {
@@ -1470,6 +1483,10 @@ void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id,
   utils::SharedPtr<smart_objects::SmartObject> message =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
+  if (!message) {
+    SDL_ERROR("Memory allocation for message failed.");
+    return;
+  }
 
   (*message)[strings::params][strings::function_id] =
       hmi_apis::FunctionID::BasicCommunication_OnResumeAudioSource;
@@ -1479,7 +1496,9 @@ void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id,
       app_mngr.GetNextHMICorrelationID();
   (*message)[strings::msg_params][strings::app_id] = app_id;
 
-  app_mngr.ManageHMICommand(message);
+  if (!app_mngr.ManageHMICommand(message)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 void MessageHelper::SendSDLActivateAppResponse(
@@ -1533,9 +1552,14 @@ void MessageHelper::SendSDLActivateAppResponse(
 
 void MessageHelper::SendOnSDLConsentNeeded(
     const policy::DeviceParams& device_info, ApplicationManager& app_man) {
+  SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr message =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
+  if (!message) {
+    SDL_ERROR("Memory allocation for message failed.");
+    return;
+  }
 
   (*message)[strings::params][strings::function_id] =
       hmi_apis::FunctionID::SDL_OnSDLConsentNeeded;
@@ -1546,7 +1570,9 @@ void MessageHelper::SendOnSDLConsentNeeded(
       device_info.device_mac_address;
   (*message)[strings::msg_params]["device"]["name"] = device_info.device_name;
 
-  app_man.ManageHMICommand(message);
+  if (!app_man.ManageHMICommand(message)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 void MessageHelper::SendPolicyUpdate(const std::string& file_path,
@@ -1571,7 +1597,7 @@ void MessageHelper::SendPolicyUpdate(const std::string& file_path,
 
 void MessageHelper::SendGetUserFriendlyMessageResponse(
     const std::vector<policy::UserFriendlyMessage>& msg,
-    uint32_t correlation_id,
+    const uint32_t correlation_id,
     ApplicationManager& app_mngr) {
   SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr message =
@@ -1654,10 +1680,10 @@ void MessageHelper::SendGetListOfPermissionsResponse(
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateNegativeResponse(
-    uint32_t connection_key,
-    int32_t function_id,
+    const uint32_t connection_key,
+    const int32_t function_id,
     const uint32_t correlation_id,
-    int32_t result_code) {
+    const int32_t result_code) {
   smart_objects::SmartObject response_data(smart_objects::SmartType_Map);
   response_data[strings::params][strings::function_id] = function_id;
   response_data[strings::params][strings::message_type] =
@@ -1793,6 +1819,7 @@ void MessageHelper::SendOnDataStreaming(
     ApplicationManager& app_mngr) {
   using namespace protocol_handler;
   using namespace helpers;
+  SDL_AUTO_TRACE();
 
   if (!Compare<ServiceType, EQ, ONE>(
           service, ServiceType::kAudio, ServiceType::kMobileNav)) {
@@ -1802,6 +1829,10 @@ void MessageHelper::SendOnDataStreaming(
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
+  if (!notification) {
+    SDL_ERROR("Memory allocation for notification failed.");
+    return;
+  }
 
   (*notification)[strings::params][strings::function_id] =
       ServiceType::kAudio == service
@@ -1816,7 +1847,9 @@ void MessageHelper::SendOnDataStreaming(
 
   (*notification)[strings::msg_params]["available"] = available;
 
-  app_mngr.ManageHMICommand(notification);
+  if (!app_mngr.ManageHMICommand(notification)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 bool MessageHelper::SendStopAudioPathThru(ApplicationManager& app_mngr) {
@@ -1832,10 +1865,14 @@ bool MessageHelper::SendStopAudioPathThru(ApplicationManager& app_mngr) {
 }
 
 bool MessageHelper::SendUnsubscribedWayPoints(ApplicationManager& app_mngr) {
-  SDL_INFO("MessageHelper::SendUnsubscribedWayPoints");
+  SDL_AUTO_TRACE();
 
   smart_objects::SmartObjectSPtr result =
       CreateRequestObject(app_mngr.GetNextHMICorrelationID());
+  if (!result) {
+    SDL_ERROR("Empty request created.");
+    return false;
+  }
 
   (*result)[strings::params][strings::function_id] =
       hmi_apis::FunctionID::Navigation_UnsubscribeWayPoints;
@@ -1844,7 +1881,7 @@ bool MessageHelper::SendUnsubscribedWayPoints(ApplicationManager& app_mngr) {
 }
 
 void MessageHelper::SendPolicySnapshotNotification(
-    uint32_t connection_key,
+    const uint32_t connection_key,
     const std::vector<uint8_t>& policy_data,
     const std::string& url,
     ApplicationManager& app_mngr) {
@@ -1948,9 +1985,10 @@ void MessageHelper::SendQueryApps(const uint32_t connection_key,
 }
 
 void MessageHelper::SendOnPermissionsChangeNotification(
-    uint32_t connection_key,
+    const uint32_t connection_key,
     const policy::Permissions& permissions,
     ApplicationManager& app_mngr) {
+  SDL_AUTO_TRACE();
   smart_objects::SmartObject content(smart_objects::SmartType_Map);
 
   content[strings::params][strings::function_id] =
@@ -2055,9 +2093,11 @@ void MessageHelper::SendOnPermissionsChangeNotification(
     }
   }
 
-  app_mngr.ManageMobileCommand(
-      utils::MakeShared<smart_objects::SmartObject>(content),
-      commands::Command::ORIGIN_SDL);
+  if (!app_mngr.ManageMobileCommand(
+          utils::MakeShared<smart_objects::SmartObject>(content),
+          commands::Command::ORIGIN_SDL)) {
+    SDL_ERROR("Unable to send notification");
+  };
 }
 
 void MessageHelper::FillAppRevokedPermissions(
@@ -2157,10 +2197,14 @@ void MessageHelper::SendGetStatusUpdateResponse(const std::string& status,
 void MessageHelper::SendUpdateSDLResponse(const std::string& result,
                                           const uint32_t correlation_id,
                                           ApplicationManager& app_mngr) {
+  SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr message =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
-  DCHECK(message);
+  if (!message) {
+    SDL_ERROR("Memory allocation for message failed.");
+    return;
+  }
 
   (*message)[strings::params][strings::function_id] =
       hmi_apis::FunctionID::SDL_UpdateSDL;
@@ -2170,15 +2214,19 @@ void MessageHelper::SendUpdateSDLResponse(const std::string& result,
 
   (*message)[strings::msg_params]["result"] = result;
 
-  app_mngr.ManageHMICommand(message);
+  if (!app_mngr.ManageHMICommand(message)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 void MessageHelper::SendOnStatusUpdate(const std::string& status,
                                        ApplicationManager& app_mngr) {
+  SDL_AUTO_TRACE();
   smart_objects::SmartObjectSPtr message =
       utils::MakeShared<smart_objects::SmartObject>(
           smart_objects::SmartType_Map);
   if (!message) {
+    SDL_ERROR("Memory allocation for message failed.");
     return;
   }
 
@@ -2189,7 +2237,9 @@ void MessageHelper::SendOnStatusUpdate(const std::string& status,
 
   (*message)[strings::msg_params]["status"] = status;
 
-  app_mngr.ManageHMICommand(message);
+  if (!app_mngr.ManageHMICommand(message)) {
+    SDL_ERROR("Unable to send HMI notification");
+  }
 }
 
 void MessageHelper::SendGetSystemInfoRequest(ApplicationManager& app_mngr) {
@@ -2416,10 +2466,7 @@ mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(
         }
         break;
       }
-      default: {
-        continue;
-        break;
-      }
+      default: { continue; }
     }
 
     soft_buttons[j++] = request_soft_buttons[i];
@@ -2436,7 +2483,7 @@ mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(
 void MessageHelper::SubscribeApplicationToSoftButton(
     smart_objects::SmartObject& message_params,
     ApplicationSharedPtr app,
-    int32_t function_id) {
+    const int32_t function_id) {
   SoftButtonID softbuttons_id;
   smart_objects::SmartObject& soft_buttons =
       message_params[strings::soft_buttons];
@@ -2447,15 +2494,13 @@ void MessageHelper::SubscribeApplicationToSoftButton(
   app->SubscribeToSoftButtons(function_id, softbuttons_id);
 }
 
-// TODO(AK): change printf to logger
 bool MessageHelper::PrintSmartObject(const smart_objects::SmartObject& object) {
-  return true;
 #ifdef ENABLE_LOG
   static uint32_t tab = 0;
   std::string tab_buffer;
 
   if (tab == 0) {
-    printf("\n-------------------------------------------------------------");
+    SDL_INFO("-------------------------------------------------------------");
   }
 
   for (uint32_t i = 0; i < tab; ++i) {
@@ -2467,9 +2512,8 @@ bool MessageHelper::PrintSmartObject(const smart_objects::SmartObject& object) {
       for (size_t i = 0; i < object.length(); i++) {
         ++tab;
 
-        printf("\n%s%zu: ", tab_buffer.c_str(), i);
+        SDL_INFO(tab_buffer << i << ": ");
         if (!PrintSmartObject(object.getElement(i))) {
-          printf("\n");
           return false;
         }
       }
@@ -2483,38 +2527,37 @@ bool MessageHelper::PrintSmartObject(const smart_objects::SmartObject& object) {
            key++) {
         ++tab;
 
-        printf("\n%s%s: ", tab_buffer.c_str(), (*key).c_str());
+        SDL_INFO(tab_buffer << (*key) << ": ");
         if (!PrintSmartObject(object[(*key).c_str()])) {
-          printf("\n");
           return false;
         }
       }
       break;
     }
     case NsSmartDeviceLink::NsSmartObjects::SmartType_Boolean:
-      object.asBool() ? printf("true\n") : printf("false\n");
+      SDL_INFO(std::boolalpha << object.asBool());
       break;
     case NsSmartDeviceLink::NsSmartObjects::SmartType_Double: {
-      printf("%f", object.asDouble());
+      SDL_INFO(object.asDouble());
       break;
     }
     case NsSmartDeviceLink::NsSmartObjects::SmartType_Integer:
       break;
     case NsSmartDeviceLink::NsSmartObjects::SmartType_String:
-      printf("%s", object.asString().c_str());
+      SDL_INFO(object.asString());
       break;
     case NsSmartDeviceLink::NsSmartObjects::SmartType_Character:
-      printf("%c", object.asChar());
+      SDL_INFO(object.asChar());
       break;
     default:
-      printf("PrintSmartObject - default case\n");
+      SDL_INFO("PrintSmartObject - default case\n");
       break;
   }
 
   if (0 != tab) {
     --tab;
   } else {
-    printf("\n-------------------------------------------------------------\n");
+    SDL_INFO("-------------------------------------------------------------");
   }
 #endif
   return true;
diff --git a/src/components/application_manager/test/message_helper/CMakeLists.txt b/src/components/application_manager/test/message_helper/CMakeLists.txt
index f57768c04b..433f2e1fbe 100755
--- a/src/components/application_manager/test/message_helper/CMakeLists.txt
+++ b/src/components/application_manager/test/message_helper/CMakeLists.txt
@@ -58,4 +58,8 @@
       link_directories(${CMAKE_SOURCE_DIR}/build/openssl_win_x64/lib/)
     endif()
 
+    if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
+    endif()
+
     create_test("message_helper_test" "${SOURCES}" "${LIBRARIES}")
diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc
index b097de587d..9888b8d4ac 100644
--- a/src/components/application_manager/test/message_helper/message_helper_test.cc
+++ b/src/components/application_manager/test/message_helper/message_helper_test.cc
@@ -61,9 +61,12 @@ typedef utils::SharedPtr<AppMock> MockApplicationSharedPtr;
 typedef std::vector<std::string> StringArray;
 typedef utils::SharedPtr<application_manager::Application> ApplicationSharedPtr;
 
-using testing::AtLeast;
-using testing::Return;
-using testing::ReturnRef;
+using ::testing::AtLeast;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SaveArg;
 
 TEST(MessageHelperTestCreate,
      CreateBlockedByPoliciesResponse_SmartObject_Equal) {
@@ -258,12 +261,14 @@ TEST(MessageHelperTestCreate,
   object[strings::cmd_icon] = 1;
   object[strings::cmd_icon][strings::value] = "10";
 
-  vis.insert(std::pair<uint32_t, smart_objects::SmartObject*>(5, &object));
+  vis.insert(CommandsMap::value_type(5, &object));
 
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   EXPECT_CALL(*appSharedMock, commands_map()).WillOnce(Return(data_accessor));
   EXPECT_CALL(*appSharedMock, app_id()).WillOnce(Return(1u));
   application_manager_test::MockApplicationManager mock_application_manager;
+  EXPECT_CALL(mock_application_manager, GetNextHMICorrelationID())
+      .WillOnce(Return(0u));
 
   smart_objects::SmartObjectList ptr =
       MessageHelper::CreateAddCommandRequestToHMI(appSharedMock,
@@ -334,6 +339,9 @@ TEST(MessageHelperTestCreate,
       .Times(AtLeast(5))
       .WillRepeatedly(Return(1u));
   application_manager_test::MockApplicationManager mock_application_manager;
+  EXPECT_CALL(mock_application_manager, GetNextHMICorrelationID())
+      .Times(AtLeast(5))
+      .WillRepeatedly(Return(0u));
 
   smart_objects::SmartObjectList ptr =
       MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(
@@ -455,171 +463,178 @@ TEST(MessageHelperTestCreate, CreateNegativeResponse_SendSmartObject_Equal) {
 
 class MessageHelperTest : public ::testing::Test {
  public:
-  MessageHelperTest() : delta_from_functions_id(32768) {
-    language_strings.push_back("EN-US");
-    language_strings.push_back("ES-MX");
-    language_strings.push_back("FR-CA");
-    language_strings.push_back("DE-DE");
-    language_strings.push_back("ES-ES");
-    language_strings.push_back("EN-GB");
-    language_strings.push_back("RU-RU");
-    language_strings.push_back("TR-TR");
-    language_strings.push_back("PL-PL");
-    language_strings.push_back("FR-FR");
-    language_strings.push_back("IT-IT");
-    language_strings.push_back("SV-SE");
-    language_strings.push_back("PT-PT");
-    language_strings.push_back("NL-NL");
-    language_strings.push_back("EN-AU");
-    language_strings.push_back("ZH-CN");
-    language_strings.push_back("ZH-TW");
-    language_strings.push_back("JA-JP");
-    language_strings.push_back("AR-SA");
-    language_strings.push_back("KO-KR");
-    language_strings.push_back("PT-BR");
-    language_strings.push_back("CS-CZ");
-    language_strings.push_back("DA-DK");
-    language_strings.push_back("NO-NO");
-    language_strings.push_back("NL-BE");
-    language_strings.push_back("EL-GR");
-    language_strings.push_back("HU-HU");
-    language_strings.push_back("FI-FI");
-    language_strings.push_back("SK-SK");
-
-    hmi_result_strings.push_back("SUCCESS");
-    hmi_result_strings.push_back("UNSUPPORTED_REQUEST");
-    hmi_result_strings.push_back("UNSUPPORTED_RESOURCE");
-    hmi_result_strings.push_back("DISALLOWED");
-    hmi_result_strings.push_back("REJECTED");
-    hmi_result_strings.push_back("ABORTED");
-    hmi_result_strings.push_back("IGNORED");
-    hmi_result_strings.push_back("RETRY");
-    hmi_result_strings.push_back("IN_USE");
-    hmi_result_strings.push_back("DATA_NOT_AVAILABLE");
-    hmi_result_strings.push_back("TIMED_OUT");
-    hmi_result_strings.push_back("INVALID_DATA");
-    hmi_result_strings.push_back("CHAR_LIMIT_EXCEEDED");
-    hmi_result_strings.push_back("INVALID_ID");
-    hmi_result_strings.push_back("DUPLICATE_NAME");
-    hmi_result_strings.push_back("APPLICATION_NOT_REGISTERED");
-    hmi_result_strings.push_back("WRONG_LANGUAGE");
-    hmi_result_strings.push_back("OUT_OF_MEMORY");
-    hmi_result_strings.push_back("TOO_MANY_PENDING_REQUESTS");
-    hmi_result_strings.push_back("NO_APPS_REGISTERED");
-    hmi_result_strings.push_back("NO_DEVICES_CONNECTED");
-    hmi_result_strings.push_back("WARNINGS");
-    hmi_result_strings.push_back("GENERIC_ERROR");
-    hmi_result_strings.push_back("USER_DISALLOWED");
-    hmi_result_strings.push_back("TRUNCATED_DATA");
-
-    mobile_result_strings.push_back("SUCCESS");
-    mobile_result_strings.push_back("UNSUPPORTED_REQUEST");
-    mobile_result_strings.push_back("UNSUPPORTED_RESOURCE");
-    mobile_result_strings.push_back("DISALLOWED");
-    mobile_result_strings.push_back("REJECTED");
-    mobile_result_strings.push_back("ABORTED");
-    mobile_result_strings.push_back("IGNORED");
-    mobile_result_strings.push_back("RETRY");
-    mobile_result_strings.push_back("IN_USE");
-    mobile_result_strings.push_back("VEHICLE_DATA_NOT_AVAILABLE");
-    mobile_result_strings.push_back("TIMED_OUT");
-    mobile_result_strings.push_back("INVALID_DATA");
-    mobile_result_strings.push_back("CHAR_LIMIT_EXCEEDED");
-    mobile_result_strings.push_back("INVALID_ID");
-    mobile_result_strings.push_back("DUPLICATE_NAME");
-    mobile_result_strings.push_back("APPLICATION_NOT_REGISTERED");
-    mobile_result_strings.push_back("WRONG_LANGUAGE");
-    mobile_result_strings.push_back("OUT_OF_MEMORY");
-    mobile_result_strings.push_back("TOO_MANY_PENDING_REQUESTS");
-    mobile_result_strings.push_back("TOO_MANY_APPLICATIONS");
-    mobile_result_strings.push_back("APPLICATION_REGISTERED_ALREADY");
-    mobile_result_strings.push_back("WARNINGS");
-    mobile_result_strings.push_back("GENERIC_ERROR");
-    mobile_result_strings.push_back("USER_DISALLOWED");
-    mobile_result_strings.push_back("TRUNCATED_DATA");
-    mobile_result_strings.push_back("UNSUPPORTED_VERSION");
-    mobile_result_strings.push_back("VEHICLE_DATA_NOT_ALLOWED");
-    mobile_result_strings.push_back("FILE_NOT_FOUND");
-    mobile_result_strings.push_back("CANCEL_ROUTE");
-    mobile_result_strings.push_back("SAVED");
-    mobile_result_strings.push_back("INVALID_CERT");
-    mobile_result_strings.push_back("EXPIRED_CERT");
-    mobile_result_strings.push_back("RESUME_FAILED");
-
-    function_id_strings.push_back("RESERVED");
-    function_id_strings.push_back("RegisterAppInterface");
-    function_id_strings.push_back("UnregisterAppInterface");
-    function_id_strings.push_back("SetGlobalProperties");
-    function_id_strings.push_back("ResetGlobalProperties");
-    function_id_strings.push_back("AddCommand");
-    function_id_strings.push_back("DeleteCommand");
-    function_id_strings.push_back("AddSubMenu");
-    function_id_strings.push_back("DeleteSubMenu");
-    function_id_strings.push_back("CreateInteractionChoiceSet");
-    function_id_strings.push_back("PerformInteraction");
-    function_id_strings.push_back("DeleteInteractionChoiceSet");
-    function_id_strings.push_back("Alert");
-    function_id_strings.push_back("Show");
-    function_id_strings.push_back("Speak");
-    function_id_strings.push_back("SetMediaClockTimer");
-    function_id_strings.push_back("PerformAudioPassThru");
-    function_id_strings.push_back("EndAudioPassThru");
-    function_id_strings.push_back("SubscribeButton");
-    function_id_strings.push_back("UnsubscribeButton");
-    function_id_strings.push_back("SubscribeVehicleData");
-    function_id_strings.push_back("UnsubscribeVehicleData");
-    function_id_strings.push_back("GetVehicleData");
-    function_id_strings.push_back("ReadDID");
-    function_id_strings.push_back("GetDTCs");
-    function_id_strings.push_back("ScrollableMessage");
-    function_id_strings.push_back("Slider");
-    function_id_strings.push_back("ShowConstantTBT");
-    function_id_strings.push_back("AlertManeuver");
-    function_id_strings.push_back("UpdateTurnList");
-    function_id_strings.push_back("ChangeRegistration");
-    function_id_strings.push_back("GenericResponse");
-    function_id_strings.push_back("PutFile");
-    function_id_strings.push_back("DeleteFile");
-    function_id_strings.push_back("ListFiles");
-    function_id_strings.push_back("SetAppIcon");
-    function_id_strings.push_back("SetDisplayLayout");
-    function_id_strings.push_back("DiagnosticMessage");
-    function_id_strings.push_back("SystemRequest");
-    function_id_strings.push_back("SendLocation");
-    function_id_strings.push_back("DialNumber");
-
-    events_id_strings.push_back("OnHMIStatus");
-    events_id_strings.push_back("OnAppInterfaceUnregistered");
-    events_id_strings.push_back("OnButtonEvent");
-    events_id_strings.push_back("OnButtonPress");
-    events_id_strings.push_back("OnVehicleData");
-    events_id_strings.push_back("OnCommand");
-    events_id_strings.push_back("OnTBTClientState");
-    events_id_strings.push_back("OnDriverDistraction");
-    events_id_strings.push_back("OnPermissionsChange");
-    events_id_strings.push_back("OnAudioPassThru");
-    events_id_strings.push_back("OnLanguageChange");
-    events_id_strings.push_back("OnKeyboardInput");
-    events_id_strings.push_back("OnTouchEvent");
-    events_id_strings.push_back("OnSystemRequest");
-    events_id_strings.push_back("OnHashChange");
-
-    hmi_level_strings.push_back("FULL");
-    hmi_level_strings.push_back("LIMITED");
-    hmi_level_strings.push_back("BACKGROUND");
-    hmi_level_strings.push_back("NONE");
+  MessageHelperTest()
+      : kDeltaFromFunctionsId(32768)
+      , kAppId(1u)
+      , kAvailable(true)
+      , kConnectionKey(1u) {
+    language_strings_.push_back("EN-US");
+    language_strings_.push_back("ES-MX");
+    language_strings_.push_back("FR-CA");
+    language_strings_.push_back("DE-DE");
+    language_strings_.push_back("ES-ES");
+    language_strings_.push_back("EN-GB");
+    language_strings_.push_back("RU-RU");
+    language_strings_.push_back("TR-TR");
+    language_strings_.push_back("PL-PL");
+    language_strings_.push_back("FR-FR");
+    language_strings_.push_back("IT-IT");
+    language_strings_.push_back("SV-SE");
+    language_strings_.push_back("PT-PT");
+    language_strings_.push_back("NL-NL");
+    language_strings_.push_back("EN-AU");
+    language_strings_.push_back("ZH-CN");
+    language_strings_.push_back("ZH-TW");
+    language_strings_.push_back("JA-JP");
+    language_strings_.push_back("AR-SA");
+    language_strings_.push_back("KO-KR");
+    language_strings_.push_back("PT-BR");
+    language_strings_.push_back("CS-CZ");
+    language_strings_.push_back("DA-DK");
+    language_strings_.push_back("NO-NO");
+    language_strings_.push_back("NL-BE");
+    language_strings_.push_back("EL-GR");
+    language_strings_.push_back("HU-HU");
+    language_strings_.push_back("FI-FI");
+    language_strings_.push_back("SK-SK");
+
+    hmi_result_strings_.push_back("SUCCESS");
+    hmi_result_strings_.push_back("UNSUPPORTED_REQUEST");
+    hmi_result_strings_.push_back("UNSUPPORTED_RESOURCE");
+    hmi_result_strings_.push_back("DISALLOWED");
+    hmi_result_strings_.push_back("REJECTED");
+    hmi_result_strings_.push_back("ABORTED");
+    hmi_result_strings_.push_back("IGNORED");
+    hmi_result_strings_.push_back("RETRY");
+    hmi_result_strings_.push_back("IN_USE");
+    hmi_result_strings_.push_back("DATA_NOT_AVAILABLE");
+    hmi_result_strings_.push_back("TIMED_OUT");
+    hmi_result_strings_.push_back("INVALID_DATA");
+    hmi_result_strings_.push_back("CHAR_LIMIT_EXCEEDED");
+    hmi_result_strings_.push_back("INVALID_ID");
+    hmi_result_strings_.push_back("DUPLICATE_NAME");
+    hmi_result_strings_.push_back("APPLICATION_NOT_REGISTERED");
+    hmi_result_strings_.push_back("WRONG_LANGUAGE");
+    hmi_result_strings_.push_back("OUT_OF_MEMORY");
+    hmi_result_strings_.push_back("TOO_MANY_PENDING_REQUESTS");
+    hmi_result_strings_.push_back("NO_APPS_REGISTERED");
+    hmi_result_strings_.push_back("NO_DEVICES_CONNECTED");
+    hmi_result_strings_.push_back("WARNINGS");
+    hmi_result_strings_.push_back("GENERIC_ERROR");
+    hmi_result_strings_.push_back("USER_DISALLOWED");
+    hmi_result_strings_.push_back("TRUNCATED_DATA");
+
+    mobile_result_strings_.push_back("SUCCESS");
+    mobile_result_strings_.push_back("UNSUPPORTED_REQUEST");
+    mobile_result_strings_.push_back("UNSUPPORTED_RESOURCE");
+    mobile_result_strings_.push_back("DISALLOWED");
+    mobile_result_strings_.push_back("REJECTED");
+    mobile_result_strings_.push_back("ABORTED");
+    mobile_result_strings_.push_back("IGNORED");
+    mobile_result_strings_.push_back("RETRY");
+    mobile_result_strings_.push_back("IN_USE");
+    mobile_result_strings_.push_back("VEHICLE_DATA_NOT_AVAILABLE");
+    mobile_result_strings_.push_back("TIMED_OUT");
+    mobile_result_strings_.push_back("INVALID_DATA");
+    mobile_result_strings_.push_back("CHAR_LIMIT_EXCEEDED");
+    mobile_result_strings_.push_back("INVALID_ID");
+    mobile_result_strings_.push_back("DUPLICATE_NAME");
+    mobile_result_strings_.push_back("APPLICATION_NOT_REGISTERED");
+    mobile_result_strings_.push_back("WRONG_LANGUAGE");
+    mobile_result_strings_.push_back("OUT_OF_MEMORY");
+    mobile_result_strings_.push_back("TOO_MANY_PENDING_REQUESTS");
+    mobile_result_strings_.push_back("TOO_MANY_APPLICATIONS");
+    mobile_result_strings_.push_back("APPLICATION_REGISTERED_ALREADY");
+    mobile_result_strings_.push_back("WARNINGS");
+    mobile_result_strings_.push_back("GENERIC_ERROR");
+    mobile_result_strings_.push_back("USER_DISALLOWED");
+    mobile_result_strings_.push_back("TRUNCATED_DATA");
+    mobile_result_strings_.push_back("UNSUPPORTED_VERSION");
+    mobile_result_strings_.push_back("VEHICLE_DATA_NOT_ALLOWED");
+    mobile_result_strings_.push_back("FILE_NOT_FOUND");
+    mobile_result_strings_.push_back("CANCEL_ROUTE");
+    mobile_result_strings_.push_back("SAVED");
+    mobile_result_strings_.push_back("INVALID_CERT");
+    mobile_result_strings_.push_back("EXPIRED_CERT");
+    mobile_result_strings_.push_back("RESUME_FAILED");
+
+    function_id_strings_.push_back("RESERVED");
+    function_id_strings_.push_back("RegisterAppInterface");
+    function_id_strings_.push_back("UnregisterAppInterface");
+    function_id_strings_.push_back("SetGlobalProperties");
+    function_id_strings_.push_back("ResetGlobalProperties");
+    function_id_strings_.push_back("AddCommand");
+    function_id_strings_.push_back("DeleteCommand");
+    function_id_strings_.push_back("AddSubMenu");
+    function_id_strings_.push_back("DeleteSubMenu");
+    function_id_strings_.push_back("CreateInteractionChoiceSet");
+    function_id_strings_.push_back("PerformInteraction");
+    function_id_strings_.push_back("DeleteInteractionChoiceSet");
+    function_id_strings_.push_back("Alert");
+    function_id_strings_.push_back("Show");
+    function_id_strings_.push_back("Speak");
+    function_id_strings_.push_back("SetMediaClockTimer");
+    function_id_strings_.push_back("PerformAudioPassThru");
+    function_id_strings_.push_back("EndAudioPassThru");
+    function_id_strings_.push_back("SubscribeButton");
+    function_id_strings_.push_back("UnsubscribeButton");
+    function_id_strings_.push_back("SubscribeVehicleData");
+    function_id_strings_.push_back("UnsubscribeVehicleData");
+    function_id_strings_.push_back("GetVehicleData");
+    function_id_strings_.push_back("ReadDID");
+    function_id_strings_.push_back("GetDTCs");
+    function_id_strings_.push_back("ScrollableMessage");
+    function_id_strings_.push_back("Slider");
+    function_id_strings_.push_back("ShowConstantTBT");
+    function_id_strings_.push_back("AlertManeuver");
+    function_id_strings_.push_back("UpdateTurnList");
+    function_id_strings_.push_back("ChangeRegistration");
+    function_id_strings_.push_back("GenericResponse");
+    function_id_strings_.push_back("PutFile");
+    function_id_strings_.push_back("DeleteFile");
+    function_id_strings_.push_back("ListFiles");
+    function_id_strings_.push_back("SetAppIcon");
+    function_id_strings_.push_back("SetDisplayLayout");
+    function_id_strings_.push_back("DiagnosticMessage");
+    function_id_strings_.push_back("SystemRequest");
+    function_id_strings_.push_back("SendLocation");
+    function_id_strings_.push_back("DialNumber");
+
+    events_id_strings_.push_back("OnHMIStatus");
+    events_id_strings_.push_back("OnAppInterfaceUnregistered");
+    events_id_strings_.push_back("OnButtonEvent");
+    events_id_strings_.push_back("OnButtonPress");
+    events_id_strings_.push_back("OnVehicleData");
+    events_id_strings_.push_back("OnCommand");
+    events_id_strings_.push_back("OnTBTClientState");
+    events_id_strings_.push_back("OnDriverDistraction");
+    events_id_strings_.push_back("OnPermissionsChange");
+    events_id_strings_.push_back("OnAudioPassThru");
+    events_id_strings_.push_back("OnLanguageChange");
+    events_id_strings_.push_back("OnKeyboardInput");
+    events_id_strings_.push_back("OnTouchEvent");
+    events_id_strings_.push_back("OnSystemRequest");
+    events_id_strings_.push_back("OnHashChange");
+
+    hmi_level_strings_.push_back("FULL");
+    hmi_level_strings_.push_back("LIMITED");
+    hmi_level_strings_.push_back("BACKGROUND");
+    hmi_level_strings_.push_back("NONE");
   }
 
  protected:
-  application_manager_test::MockApplicationManager mock_application_manager;
-  StringArray language_strings;
-  StringArray hmi_result_strings;
-  StringArray mobile_result_strings;
-  StringArray function_id_strings;
-  StringArray events_id_strings;
-  StringArray hmi_level_strings;
-
-  const size_t delta_from_functions_id;
+  application_manager_test::MockApplicationManager mock_application_manager_;
+  StringArray language_strings_;
+  StringArray hmi_result_strings_;
+  StringArray mobile_result_strings_;
+  StringArray function_id_strings_;
+  StringArray events_id_strings_;
+  StringArray hmi_level_strings_;
+
+  const size_t kDeltaFromFunctionsId;
+  const uint32_t kAppId;
+  const bool kAvailable;
+  const uint32_t kConnectionKey;
 };
 
 TEST_F(MessageHelperTest,
@@ -627,11 +642,11 @@ TEST_F(MessageHelperTest,
   HmiLanguage::eType enum_value;
   HmiLanguage::eType enum_from_string_value;
   // Check all languages >= 0
-  for (size_t array_index = 0; array_index < language_strings.size();
+  for (size_t array_index = 0; array_index < language_strings_.size();
        ++array_index) {
     enum_value = static_cast<HmiLanguage::eType>(array_index);
     enum_from_string_value =
-        MessageHelper::CommonLanguageFromString(language_strings[array_index]);
+        MessageHelper::CommonLanguageFromString(language_strings_[array_index]);
     EXPECT_EQ(enum_value, enum_from_string_value);
   }
   // Check InvalidEnum == -1
@@ -645,11 +660,11 @@ TEST_F(MessageHelperTest,
   std::string string_from_enum;
   HmiLanguage::eType casted_enum;
   // Check all languages >=0
-  for (size_t array_index = 0; array_index < language_strings.size();
+  for (size_t array_index = 0; array_index < language_strings_.size();
        ++array_index) {
     casted_enum = static_cast<HmiLanguage::eType>(array_index);
     string_from_enum = MessageHelper::CommonLanguageToString(casted_enum);
-    EXPECT_EQ(language_strings[array_index], string_from_enum);
+    EXPECT_EQ(language_strings_[array_index], string_from_enum);
   }
   // Check InvalidEnum == -1
   string_from_enum =
@@ -671,11 +686,11 @@ TEST_F(MessageHelperTest, HMIResultFromString_StringValueOfEnum_CorrectEType) {
   HmiResults::eType enum_value;
   HmiResults::eType enum_from_string_value;
   // Check all results >= 0
-  for (size_t array_index = 0; array_index < hmi_result_strings.size();
+  for (size_t array_index = 0; array_index < hmi_result_strings_.size();
        ++array_index) {
     enum_value = static_cast<HmiResults::eType>(array_index);
     enum_from_string_value =
-        MessageHelper::HMIResultFromString(hmi_result_strings[array_index]);
+        MessageHelper::HMIResultFromString(hmi_result_strings_[array_index]);
     EXPECT_EQ(enum_value, enum_from_string_value);
   }
   // Check InvalidEnum == -1
@@ -688,11 +703,11 @@ TEST_F(MessageHelperTest, HMIResultToString_ETypeValueOfEnum_CorrectString) {
   std::string string_from_enum;
   HmiResults::eType casted_enum;
   // Check all results >=0
-  for (size_t array_index = 0; array_index < hmi_result_strings.size();
+  for (size_t array_index = 0; array_index < hmi_result_strings_.size();
        ++array_index) {
     casted_enum = static_cast<HmiResults::eType>(array_index);
     string_from_enum = MessageHelper::HMIResultToString(casted_enum);
-    EXPECT_EQ(hmi_result_strings[array_index], string_from_enum);
+    EXPECT_EQ(hmi_result_strings_[array_index], string_from_enum);
   }
   // Check InvalidEnum == -1
   string_from_enum = MessageHelper::HMIResultToString(HmiResults::INVALID_ENUM);
@@ -705,10 +720,10 @@ TEST_F(MessageHelperTest,
   HmiResults::eType casted_hmi_enum;
   MobileResults::eType converted_enum;
   // Check enums >=0
-  for (size_t enum_index = 0; enum_index < hmi_result_strings.size();
+  for (size_t enum_index = 0; enum_index < hmi_result_strings_.size();
        ++enum_index) {
     tested_enum =
-        MessageHelper::MobileResultFromString(hmi_result_strings[enum_index]);
+        MessageHelper::MobileResultFromString(hmi_result_strings_[enum_index]);
     casted_hmi_enum = static_cast<HmiResults::eType>(enum_index);
     converted_enum = MessageHelper::HMIToMobileResult(casted_hmi_enum);
     EXPECT_EQ(tested_enum, converted_enum);
@@ -758,14 +773,18 @@ TEST_F(MessageHelperTest,
   DataAccessor<application_manager::VehicleInfoSubscriptions> data_accessor(
       vis, lock);
 
-  // Calls for ApplicationManager
+// Calls for ApplicationManager
+#ifdef HMI_JSON_API
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(0u));
+#endif
   // Creating sharedPtr to MockApplication
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   EXPECT_CALL(*appSharedMock, app_id()).WillOnce(Return(1u));
   EXPECT_CALL(*appSharedMock, SubscribedIVI()).WillOnce(Return(data_accessor));
   smart_objects::SmartObjectList outList =
       MessageHelper::GetIVISubscriptionRequests(appSharedMock,
-                                                mock_application_manager);
+                                                mock_application_manager_);
   // Expect not empty request
   EXPECT_FALSE(outList.empty());
 }
@@ -776,12 +795,12 @@ TEST_F(MessageHelperTest,
   smart_objects::SmartObject object;
   policy_handler_test::MockPolicySettings policy_settings_;
   policy::PolicyHandler policy_handler(policy_settings_,
-                                       mock_application_manager);
+                                       mock_application_manager_);
   // Method call
   // Creating sharedPtr to MockApplication
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   mobile_apis::Result::eType result = MessageHelper::ProcessSoftButtons(
-      object, appSharedMock, policy_handler, mock_application_manager);
+      object, appSharedMock, policy_handler, mock_application_manager_);
   // Expect
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -795,12 +814,12 @@ TEST_F(MessageHelperTest,
   buttons[0][strings::image][strings::value] = "invalid\\nvalue";
   policy_handler_test::MockPolicySettings policy_settings_;
   const policy::PolicyHandler policy_handler(policy_settings_,
-                                             mock_application_manager);
+                                             mock_application_manager_);
   // Creating sharedPtr to MockApplication
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<AppMock>();
   // Method call
   mobile_apis::Result::eType result = MessageHelper::ProcessSoftButtons(
-      object, appSharedMock, policy_handler, mock_application_manager);
+      object, appSharedMock, policy_handler, mock_application_manager_);
   // Expect
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -813,7 +832,7 @@ TEST_F(MessageHelperTest, VerifyImage_ImageTypeIsStatic_Success) {
   image[strings::image_type] = mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImage(
-      image, appSharedMock, mock_application_manager);
+      image, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -828,7 +847,7 @@ TEST_F(MessageHelperTest, VerifyImage_ImageValueNotValid_InvalidData) {
   image[strings::value] = "   ";
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImage(
-      image, appSharedMock, mock_application_manager);
+      image, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -842,7 +861,7 @@ TEST_F(MessageHelperTest, VerifyImageFiles_SmartObjectWithValidData_Success) {
   images[1][strings::image_type] = mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImageFiles(
-      images, appSharedMock, mock_application_manager);
+      images, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -860,7 +879,7 @@ TEST_F(MessageHelperTest,
   images[1][strings::value] = "image\\n";
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImageFiles(
-      images, appSharedMock, mock_application_manager);
+      images, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -877,7 +896,7 @@ TEST_F(MessageHelperTest,
       mobile_apis::ImageType::STATIC;
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImageVrHelpItems(
-      message, appSharedMock, mock_application_manager);
+      message, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::SUCCESS, result);
 }
@@ -897,7 +916,7 @@ TEST_F(MessageHelperTest,
   message[1][strings::image][strings::value] = "image\\n";
   // Method call
   mobile_apis::Result::eType result = MessageHelper::VerifyImageVrHelpItems(
-      message, appSharedMock, mock_application_manager);
+      message, appSharedMock, mock_application_manager_);
   // EXPECT
   EXPECT_EQ(mobile_apis::Result::INVALID_DATA, result);
 }
@@ -908,18 +927,18 @@ TEST_F(MessageHelperTest,
   // 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) {
+  for (size_t i = 1; i < function_id_strings_.size(); ++i) {
     casted_enum = static_cast<mobile_apis::FunctionID::eType>(i);
     converted = MessageHelper::StringifiedFunctionID(casted_enum);
-    EXPECT_EQ(function_id_strings[i], converted);
+    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;
+  for (size_t i = kDeltaFromFunctionsId;
+       i < events_id_strings_.size() + kDeltaFromFunctionsId;
        ++i) {
     casted_enum = static_cast<mobile_apis::FunctionID::eType>(i);
     converted = MessageHelper::StringifiedFunctionID(casted_enum);
-    EXPECT_EQ(events_id_strings[i - delta_from_functions_id], converted);
+    EXPECT_EQ(events_id_strings_[i - kDeltaFromFunctionsId], converted);
   }
 }
 
@@ -927,19 +946,19 @@ TEST_F(MessageHelperTest,
        StringifiedHmiLevel_LevelEnum_EqualsWithStringsInArray) {
   mobile_apis::HMILevel::eType casted_enum;
   std::string converted_value;
-  for (size_t i = 0; i < hmi_level_strings.size(); ++i) {
+  for (size_t i = 0; i < hmi_level_strings_.size(); ++i) {
     casted_enum = static_cast<mobile_apis::HMILevel::eType>(i);
     converted_value = MessageHelper::StringifiedHMILevel(casted_enum);
-    EXPECT_EQ(hmi_level_strings[i], converted_value);
+    EXPECT_EQ(hmi_level_strings_[i], converted_value);
   }
 }
 
 TEST_F(MessageHelperTest, StringToHmiLevel_LevelString_EqEType) {
   mobile_apis::HMILevel::eType tested_enum;
   mobile_apis::HMILevel::eType converted_enum;
-  for (size_t i = 0; i < hmi_level_strings.size(); ++i) {
+  for (size_t i = 0; i < hmi_level_strings_.size(); ++i) {
     tested_enum = static_cast<mobile_apis::HMILevel::eType>(i);
-    converted_enum = MessageHelper::StringToHMILevel(hmi_level_strings[i]);
+    converted_enum = MessageHelper::StringToHMILevel(hmi_level_strings_[i]);
     EXPECT_EQ(tested_enum, converted_enum);
   }
 }
@@ -957,6 +976,422 @@ TEST_F(MessageHelperTest, SubscribeApplicationToSoftButton_CallFromApp) {
       message_params, appSharedPtr, function_id);
 }
 
+TEST_F(MessageHelperTest, SendOnAppUnregNotificationToHMI) {
+  const bool kIsUnexpectedDisconnect = false;
+
+  MockApplicationSharedPtr mock_app = ::utils::MakeShared<AppMock>();
+
+  const uint32_t kMockHmiAppId = 1u;
+  EXPECT_CALL(*mock_app, hmi_app_id()).WillOnce(Return(kMockHmiAppId));
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnAppUnregNotificationToHMI(
+      mock_app, kIsUnexpectedDisconnect, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      MessageType::kNotification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(kMockHmiAppId,
+            (*test_notification)[strings::msg_params][strings::app_id].asInt());
+  EXPECT_EQ(
+      kIsUnexpectedDisconnect,
+      (*test_notification)[strings::msg_params][strings::unexpected_disconnect]
+          .asInt());
+}
+
+TEST_F(MessageHelperTest, SendOnAppUnregNotificationToHMI_InvalidApp) {
+  const bool kIsUnexpectedDisconnect = false;
+
+  MockApplicationSharedPtr mock_app;
+
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  MessageHelper::SendOnAppUnregNotificationToHMI(
+      mock_app, kIsUnexpectedDisconnect, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendOnButtonSubscriptionNotification) {
+  const hmi_apis::Common_ButtonName::eType kButton =
+      hmi_apis::Common_ButtonName::OK;
+  const bool kIsSubscribed = true;
+
+  smart_objects::SmartObject msg_params(smart_objects::SmartType_Map);
+  msg_params[strings::app_id] = kAppId;
+  msg_params[strings::name] = kButton;
+  msg_params[strings::is_suscribed] = kIsSubscribed;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnButtonSubscriptionNotification(
+      kAppId, kButton, kIsSubscribed, mock_application_manager_);
+
+  EXPECT_EQ(
+      application_manager::MessageType::kNotification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::protocol_version_,
+      (*test_notification)[strings::params][strings::protocol_version].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::hmi_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(
+      hmi_apis::FunctionID::Buttons_OnButtonSubscription,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::FunctionID::Buttons_OnButtonSubscription,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(msg_params, (*test_notification)[strings::msg_params]);
+}
+
+TEST_F(MessageHelperTest, SendOnDataStreaming_Audio) {
+  const protocol_handler::ServiceType kService =
+      protocol_handler::ServiceType::kAudio;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnDataStreaming(
+      kService, kAvailable, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::Navigation_OnAudioDataStreaming,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::messageType::notification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::protocol_version_,
+      (*test_notification)[strings::params][strings::protocol_version].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::hmi_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(kAvailable,
+            (*test_notification)[strings::msg_params]["available"].asInt());
+}
+
+TEST_F(MessageHelperTest, SendOnDataStreaming_MobileNav) {
+  const protocol_handler::ServiceType kService =
+      protocol_handler::ServiceType::kMobileNav;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnDataStreaming(
+      kService, kAvailable, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::Navigation_OnVideoDataStreaming,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::messageType::notification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::protocol_version_,
+      (*test_notification)[strings::params][strings::protocol_version].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::hmi_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(kAvailable,
+            (*test_notification)[strings::msg_params]["available"].asInt());
+}
+
+TEST_F(MessageHelperTest, SendOnDataStreaming_Fail) {
+  const protocol_handler::ServiceType kService =
+      protocol_handler::ServiceType::kInvalidServiceType;
+
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  MessageHelper::SendOnDataStreaming(
+      kService, kAvailable, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendOnPermissionsChangeNotification) {
+  const policy::RpcName kRpcName1 = "rpc_name_1";
+  const std::string kHMIPermissionLabel1 = "level_1";
+  const std::string kHMIPermissionValue1 = "hmi_level_1";
+
+  std::set<policy::HMILevel> hmi_levels_1;
+  hmi_levels_1.insert(kHMIPermissionValue1);
+
+  policy::HMIPermissions hmi_permissions_1;
+  hmi_permissions_1[kHMIPermissionLabel1] = hmi_levels_1;
+
+  std::set<policy::Parameter> parameters_1;
+  parameters_1.insert("parameter_1");
+
+  policy::ParameterPermissions parameter_permissions_1;
+  parameter_permissions_1["1"] = parameters_1;
+
+  const policy::RpcPermissions kRpcPermissions1 = {hmi_permissions_1,
+                                                   parameter_permissions_1};
+
+  policy::Permissions permissions;
+  permissions[kRpcName1] = kRpcPermissions1;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_,
+              ManageMobileCommand(_, commands::Command::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnPermissionsChangeNotification(
+      kConnectionKey, permissions, mock_application_manager_);
+
+  EXPECT_EQ(
+      mobile_apis::FunctionID::OnPermissionsChangeID,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      mobile_apis::messageType::notification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::mobile_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(
+      kConnectionKey,
+      (*test_notification)[strings::params][strings::connection_key].asUInt());
+
+  // Permissions Data check
+  policy::Permissions::const_iterator it_permissions = permissions.begin();
+  policy::Permissions::const_iterator it_permissions_end = permissions.end();
+  const smart_objects::SmartObject& kPermissionsItemArray =
+      (*test_notification)[strings::msg_params]["permissionItem"];
+
+  for (size_t index_pi = 0; it_permissions != it_permissions_end;
+       ++it_permissions, ++index_pi) {
+    const smart_objects::SmartObject& kPermissionItem =
+        kPermissionsItemArray[index_pi];
+
+    EXPECT_EQ((*it_permissions).first, kPermissionItem["rpcName"].asString());
+
+    // Checking the hmiPermissions
+    const smart_objects::SmartObject& kHmiPermissions =
+        kPermissionItem["hmiPermissions"];
+    const policy::RpcPermissions& rpc_permissions = (*it_permissions).second;
+    policy::HMIPermissions::const_iterator it_hmi_permissions =
+        rpc_permissions.hmi_permissions.begin();
+    policy::HMIPermissions::const_iterator it_hmi_permissions_end =
+        rpc_permissions.hmi_permissions.end();
+
+    for (; it_hmi_permissions != it_hmi_permissions_end; ++it_hmi_permissions) {
+      std::set<policy::HMILevel>::const_iterator it_hmi_levels =
+          (*it_hmi_permissions).second.begin();
+      std::set<policy::HMILevel>::const_iterator it_hmi_levels_end =
+          (*it_hmi_permissions).second.end();
+      const smart_objects::SmartObject& kHmiLevels =
+          kHmiPermissions[(*it_hmi_permissions).first];
+
+      for (size_t index_hmi_levels = 0; it_hmi_levels != it_hmi_levels_end;
+           ++it_hmi_levels, ++index_hmi_levels) {
+        EXPECT_EQ(kHMIPermissionValue1,
+                  kHmiLevels[index_hmi_levels].asString());
+      }
+    }
+
+    // Checking the parameterPermissions
+    const smart_objects::SmartObject& kParameterPermissions =
+        kPermissionItem["parameterPermissions"];
+    policy::ParameterPermissions::const_iterator it_parameter_permissions =
+        rpc_permissions.parameter_permissions.begin();
+    policy::ParameterPermissions::const_iterator it_parameter_permissions_end =
+        rpc_permissions.parameter_permissions.end();
+
+    for (; it_parameter_permissions != it_parameter_permissions_end;
+         ++it_parameter_permissions) {
+      const smart_objects::SmartObject& kParameters =
+          kParameterPermissions[(*it_parameter_permissions).first];
+
+      std::set<policy::Parameter>::const_iterator it_parameters =
+          (*it_parameter_permissions).second.begin();
+      std::set<policy::Parameter>::const_iterator it_parameters_end =
+          (*it_parameter_permissions).second.end();
+
+      for (size_t index_parameters = 0; it_parameters != it_parameters_end;
+           ++it_parameters, ++index_parameters) {
+        EXPECT_EQ(*it_parameters, kParameters[index_parameters].asString());
+      }
+    }
+  }
+}
+
+TEST_F(MessageHelperTest, SendOnResumeAudioSourceToHMI) {
+  MockApplicationSharedPtr mock_app = utils::MakeShared<AppMock>();
+  EXPECT_CALL(mock_application_manager_, application(kAppId))
+      .WillOnce(Return(mock_app));
+  EXPECT_EQ(mock_app, true);
+
+  const uint32_t kCorrelationId = 0;
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnResumeAudioSourceToHMI(kAppId,
+                                              mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::BasicCommunication_OnResumeAudioSource,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      MessageType::kNotification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      kCorrelationId,
+      (*test_notification)[strings::params][strings::correlation_id].asUInt());
+  EXPECT_EQ(kAppId,
+            (*test_notification)[strings::msg_params][strings::app_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendOnResumeAudioSourceToHMI_InvalidAppId) {
+  MockApplicationSharedPtr mock_app;
+  EXPECT_CALL(mock_application_manager_, application(kAppId))
+      .WillOnce(Return(MockApplicationSharedPtr()));
+  EXPECT_EQ(mock_app, false);
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID()).Times(0);
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  MessageHelper::SendOnResumeAudioSourceToHMI(kAppId,
+                                              mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendOnSDLConsentNeeded) {
+  const policy::DeviceParams kDeviceInfo;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnSDLConsentNeeded(kDeviceInfo, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::SDL_OnSDLConsentNeeded,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      MessageType::kNotification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      kDeviceInfo.device_mac_address,
+      (*test_notification)[strings::msg_params]["device"]["id"].asString());
+  EXPECT_EQ(
+      kDeviceInfo.device_name,
+      (*test_notification)[strings::msg_params]["device"]["name"].asString());
+}
+
+TEST_F(MessageHelperTest, SendOnStatusUpdate) {
+  const std::string& kStatus = "test_status";
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendOnStatusUpdate(kStatus, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::SDL_OnStatusUpdate,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      MessageType::kNotification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(kStatus,
+            (*test_notification)[strings::msg_params]["status"].asString());
+}
+
+TEST_F(MessageHelperTest, SendPolicySnapshotNotification) {
+  const std::vector<uint8_t> kPolicyData;
+  const std::string& kUrl = "test_url";
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_,
+              ManageMobileCommand(_, commands::Command::ORIGIN_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendPolicySnapshotNotification(
+      kConnectionKey, kPolicyData, kUrl, mock_application_manager_);
+
+  EXPECT_EQ(
+      mobile_apis::FunctionID::OnSystemRequestID,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      mobile_apis::messageType::notification,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::mobile_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::protocol_version_,
+      (*test_notification)[strings::params][strings::protocol_version].asInt());
+  EXPECT_EQ(
+      kConnectionKey,
+      (*test_notification)[strings::params][strings::connection_key].asInt());
+  EXPECT_EQ(kUrl,
+            (*test_notification)[strings::msg_params][strings::url].asString());
+}
+
+TEST_F(MessageHelperTest, SendUnsubscribedWayPoints) {
+  const uint32_t kCorrelationId = 0;
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  const bool kRes =
+      MessageHelper::SendUnsubscribedWayPoints(mock_application_manager_);
+  EXPECT_TRUE(kRes);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::Navigation_UnsubscribeWayPoints,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::messageType::request,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::protocol_version_,
+      (*test_notification)[strings::params][strings::protocol_version].asInt());
+  EXPECT_EQ(
+      commands::CommandImpl::hmi_protocol_type_,
+      (*test_notification)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(
+      kCorrelationId,
+      (*test_notification)[strings::params][strings::correlation_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendUpdateSDLResponse) {
+  const std::string& kResult = "test_result";
+  const uint32_t kCorrelationId = 1u;
+
+  smart_objects::SmartObjectSPtr test_notification;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&test_notification), Return(true)));
+
+  MessageHelper::SendUpdateSDLResponse(
+      kResult, kCorrelationId, mock_application_manager_);
+
+  EXPECT_EQ(
+      hmi_apis::FunctionID::SDL_UpdateSDL,
+      (*test_notification)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      MessageType::kResponse,
+      (*test_notification)[strings::params][strings::message_type].asInt());
+  EXPECT_EQ(
+      kCorrelationId,
+      (*test_notification)[strings::params][strings::correlation_id].asInt());
+  EXPECT_EQ(0,
+            (*test_notification)[strings::params][hmi_response::code].asInt());
+  EXPECT_EQ(kResult,
+            (*test_notification)[strings::msg_params]["result"].asString());
+}
+
 TEST(MessageHelperTestCreate, CreateHashUpdateNotification_FunctionId_Equal) {
   const uint32_t kApplicationId = 0;
   const smart_objects::SmartObjectSPtr kNotificationSPtr =
@@ -1013,11 +1448,11 @@ TEST_F(MessageHelperTest,
   MobileResults::eType tested_enum;
   MobileResults::eType converted_enum;
   // Check enums >=0
-  for (size_t array_index = 0; array_index < mobile_result_strings.size();
+  for (size_t array_index = 0; array_index < mobile_result_strings_.size();
        ++array_index) {
     tested_enum = static_cast<MobileResults::eType>(array_index);
     converted_enum = MessageHelper::MobileResultFromString(
-        mobile_result_strings[array_index]);
+        mobile_result_strings_[array_index]);
     EXPECT_EQ(tested_enum, converted_enum);
   }
   // Check invalid enums == -1
@@ -1030,11 +1465,11 @@ TEST_F(MessageHelperTest, MobileResultToString_ETypeValueOfEnum_CorrectString) {
   std::string string_from_enum;
   MobileResults::eType casted_enum;
   // Check all results >=0
-  for (size_t array_index = 0; array_index < mobile_result_strings.size();
+  for (size_t array_index = 0; array_index < mobile_result_strings_.size();
        ++array_index) {
     casted_enum = static_cast<MobileResults::eType>(array_index);
     string_from_enum = MessageHelper::MobileResultToString(casted_enum);
-    EXPECT_EQ(mobile_result_strings[array_index], string_from_enum);
+    EXPECT_EQ(mobile_result_strings_[array_index], string_from_enum);
   }
   // Check InvalidEnum == -1
   string_from_enum =
@@ -1048,10 +1483,10 @@ TEST_F(MessageHelperTest,
   MobileResults::eType casted_mobile_enum;
   HmiResults::eType converted_enum;
   // Check enums >=0
-  for (size_t enum_index = 0; enum_index < mobile_result_strings.size();
+  for (size_t enum_index = 0; enum_index < mobile_result_strings_.size();
        ++enum_index) {
     tested_enum =
-        MessageHelper::HMIResultFromString(mobile_result_strings[enum_index]);
+        MessageHelper::HMIResultFromString(mobile_result_strings_[enum_index]);
     casted_mobile_enum = static_cast<MobileResults::eType>(enum_index);
     converted_enum = MessageHelper::MobileToHMIResult(casted_mobile_enum);
     EXPECT_EQ(tested_enum, converted_enum);