Adds draft business logic for 'CCS ON' case and unit test

28 files changed, 4435 insertions, 1334 deletions

diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h
index f4b86ede7b..01b10b1c63 100644
--- a/src/components/application_manager/include/application_manager/policies/policy_handler.h
+++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h
@@ -199,8 +199,19 @@ class PolicyHandler : public PolicyHandlerInterface,
    * should be applied to all applications
    * @param permissions User-changed group permissions consent
    */
+
+  /**
+   * @brief Processes permissions changes received from system via
+   * OnAppPermissionConsent notification
+   * @param connection_key Connection key of application, 0 if no key has been
+   * provided by notification
+   * @param permissions Structure containing group permissions changes
+   * @param ccs_status Structure containig customer connectivity settings
+   * changes
+   */
   void OnAppPermissionConsent(const uint32_t connection_key,
-                              const PermissionConsent& permissions) OVERRIDE;
+                              const PermissionConsent& permissions,
+                              const CCSStatus& ccs_status) FINAL;
 
   /**
    * @brief Get appropriate message parameters and send them with response
@@ -244,6 +255,13 @@ class PolicyHandler : public PolicyHandlerInterface,
       const std::string& policy_app_id) OVERRIDE;
 
   /**
+ * @brief Collects currently registered applications ids linked to their
+ * device id
+ * @return Collection of device_id-to-app_id links
+ */
+  ApplicationsLinks GetRegisteredLinks() const FINAL;
+
+  /**
    * @brief Set parameters from OnSystemInfoChanged to policy table
    * @param language System language
    */
@@ -460,14 +478,19 @@ class PolicyHandler : public PolicyHandlerInterface,
   bool CheckStealFocus(const std::string& policy_app_id) const;
 
   /**
-   * @brief OnAppPermissionConsentInternal reacts on permission changing
-   *
-   * @param connection_key connection key
-   *
-   * @param permissions new permissions.
+   * @brief Processes data received via OnAppPermissionChanged notification
+   * from. Being started asyncronously from AppPermissionDelegate class.
+   * Sets updated permissions and CCS for registered applications and
+   * applications which already have appropriate group assigned which related to
+   * devices already known by policy
+   * @param connection_key Connection key of application, 0 if no key has been
+   * provided within notification
+   * @param ccs_status Customer connectivity settings changes to process
+   * @param permissions Permissions changes to process
    */
   void OnAppPermissionConsentInternal(const uint32_t connection_key,
-                                      PermissionConsent& permissions) OVERRIDE;
+                                      const CCSStatus& ccs_status,
+                                      PermissionConsent& out_permissions) FINAL;
 
   /**
    * @brief Sets days after epoch on successful policy update
@@ -545,6 +568,32 @@ class PolicyHandler : public PolicyHandlerInterface,
   void GetRegisteredLinks(std::map<std::string, std::string>& out_links) const;
 
   static const std::string kLibrary;
+
+  /**
+   * @brief Collects permissions for all currently registered applications on
+   * all devices
+   * @return consolidated permissions list or empty list if no
+   * applications/devices currently present
+   */
+  std::vector<FunctionalGroupPermission> CollectRegisteredAppsPermissions();
+
+  /**
+   * @brief Collects permissions for application with certain connection key
+   * @param connection_key Connection key of application to look for
+   * @return list of application permissions or empty list if no such
+   * application found
+   */
+  std::vector<FunctionalGroupPermission> CollectAppPermissions(
+      const uint32_t connection_key);
+
+  /**
+ * @brief Collects currently registered applications ids linked to their
+ * device id
+ * @param out_links Collection of device_id-to-app_id links
+ */
+  void GetRegisteredLinks(ApplicationsLinks& out_links) const;
+
+ private:
   mutable sync_primitives::RWLock policy_manager_lock_;
   utils::SharedPtr<PolicyManager> policy_manager_;
   void* dl_handle_;
@@ -564,10 +613,11 @@ class PolicyHandler : public PolicyHandlerInterface,
   mutable sync_primitives::Lock listeners_lock_;
 
   /**
-   * @brief Application-to-device map is used for getting/setting user consents
-   * for all apps
+   * @brief Application-to-device links are used for collecting their current
+   * consents to provide for HMI request and process response with possible
+   * changes done by user
    */
-  std::map<std::string, std::string> app_to_device_link_;
+  ApplicationsLinks app_to_device_link_;
 
   // Lock for app to device list
   sync_primitives::Lock app_to_device_link_lock_;
diff --git a/src/components/application_manager/include/application_manager/smart_object_keys.h b/src/components/application_manager/include/application_manager/smart_object_keys.h
index e751f164d3..7ea3a7a20e 100644
--- a/src/components/application_manager/include/application_manager/smart_object_keys.h
+++ b/src/components/application_manager/include/application_manager/smart_object_keys.h
@@ -310,6 +310,28 @@ extern const char* is_suscribed;
 extern const char* message_data;
 
 extern const char* delivery_mode;
+
+extern const char* audio_streaming_indicator;
+
+// keys for default parameters loaded from hmi_capabilities.json:
+extern const char* const keyboard_properties_default;
+extern const char* const language_default;
+extern const char* const keyboard_layout_default;
+extern const char* const keypress_mode_default;
+
+// keys for supported parameters loaded from hmi_capabilities.json:
+extern const char* const keyboard_properties_supported;
+extern const char* const language_supported;
+extern const char* const keyboard_layout_supported;
+extern const char* const keypress_mode_supported;
+extern const char* const limited_characters_list_supported;
+extern const char* const auto_complete_text_supported;
+extern const char* const entity_type;
+extern const char* const entity_id;
+extern const char* const status;
+extern const char* const ccs_status;
+extern const char* const consented_functions;
+extern const char* const source;
 }  // namespace strings
 
 namespace json {
diff --git a/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
index 0efc1aee8a..2219d508ff 100644
--- a/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
@@ -35,6 +35,74 @@
 #include "application_manager/application_manager.h"
 #include "application_manager/policies/policy_handler.h"
 #include "application_manager/message_helper.h"
+#include <algorithm>
+#include <functional>
+#include <string>
+#include "policy/policy_types.h"
+#include "smart_objects/smart_object.h"
+
+namespace {
+
+/**
+ * @brief Converts SmartObject data to group permission status and appends to
+ * collection
+ */
+struct PermissionsAppender
+    : public std::unary_function<void,
+                                 const smart_objects::SmartArray::value_type&> {
+  PermissionsAppender(policy::PermissionConsent& consents)
+      : allowed_key_(application_manager::hmi_response::allowed)
+      , consents_(consents) {}
+  void operator()(const smart_objects::SmartArray::value_type& item) const {
+    using namespace policy;
+    using namespace application_manager;
+
+    FunctionalGroupPermission permissions;
+
+    permissions.group_id = static_cast<int32_t>(item[strings::id].asInt());
+    permissions.group_alias = item[strings::name].asString();
+
+    if (item.keyExists(allowed_key_)) {
+      permissions.state =
+          item[allowed_key_].asBool() ? kGroupAllowed : kGroupDisallowed;
+    }
+
+    consents_.group_permissions.push_back(permissions);
+  }
+
+ private:
+  const std::string allowed_key_;
+  policy::PermissionConsent& consents_;
+};
+
+/**
+ * @brief Converts SmartObject data to customer connectivity status item and
+ * appends to collection
+ */
+struct CCSStatusAppender
+    : std::unary_function<void, const smart_objects::SmartArray::value_type&> {
+  CCSStatusAppender(policy::CCSStatus& ccs_status) : ccs_status_(ccs_status) {}
+  void operator()(const smart_objects::SmartArray::value_type& item) const {
+    using namespace policy;
+    using namespace hmi_apis;
+    using namespace application_manager;
+
+    CCSStatusItem status_item(
+        static_cast<uint32_t>(item[strings::entity_type].asUInt()),
+        static_cast<uint32_t>(item[strings::entity_id].asUInt()),
+        static_cast<Common_EntityStatus::eType>(
+            item[strings::status].asUInt()) == Common_EntityStatus::ON
+            ? policy::kStatusOn
+            : policy::kStatusOff);
+
+    ccs_status_.insert(status_item);
+  }
+
+ private:
+  policy::CCSStatus& ccs_status_;
+};
+
+}  // namespace
 
 namespace application_manager {
 
@@ -54,10 +122,10 @@ void OnAppPermissionConsentNotification::Run() {
 
   policy::PermissionConsent permission_consent;
 
-  // If user defined group permissions for specific app
-  if (msg_params.keyExists(strings::app_id)) {
-    connection_key = msg_params[strings::app_id].asUInt();
-  }
+  PermissionConsent permission_consent;
+  if (msg_params.keyExists(strings::consented_functions)) {
+    const SmartArray* user_consents =
+        msg_params[strings::consented_functions].asArray();
 
   if (msg_params.keyExists("consentedFunctions")) {
     smart_objects::SmartArray* user_consent =
@@ -80,7 +148,13 @@ void OnAppPermissionConsentNotification::Run() {
       permission_consent.group_permissions.push_back(permissions);
     }
 
-    permission_consent.consent_source = msg_params["source"].asString();
+    permission_consent.consent_source = msg_params[strings::source].asString();
+  }
+
+  CCSStatus ccs_status;
+  if (msg_params.keyExists(strings::ccs_status)) {
+    const SmartArray* system_ccs_status =
+        msg_params[strings::ccs_status].asArray();
 
     application_manager_.GetPolicyHandler().OnAppPermissionConsent(
         connection_key, permission_consent);
diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc
index c0567b75f0..45d2de46a1 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -96,8 +96,91 @@ bool ValidateSoftButtons(smart_objects::SmartObject& soft_buttons) {
     }
   }
   return true;
-}  // namespace
 }
+
+struct GroupsAppender
+    : std::unary_function<void, const PermissionsList::value_type&> {
+  GroupsAppender(smart_objects::SmartObject& groups)
+      : groups_(groups), index_(0) {}
+
+  void operator()(const PermissionsList::value_type& item) {
+    using namespace smart_objects;
+    using namespace policy;
+    groups_[index_] = SmartObject(SmartType_Map);
+
+    SmartObject& group = groups_[index_];
+    group[strings::name] = item.group_alias;
+    group[strings::id] = item.group_id;
+    GroupConsent permission_state = item.state;
+    // If state undefined, 'allowed' parameter should be absent
+    if (kGroupUndefined != permission_state) {
+      group["allowed"] = kGroupAllowed == permission_state;
+    }
+    ++index_;
+  }
+
+ private:
+  smart_objects::SmartObject& groups_;
+  int32_t index_;
+};
+
+struct GroupsAppender
+    : std::unary_function<void, const PermissionsList::value_type&> {
+  GroupsAppender(smart_objects::SmartObject& groups)
+      : groups_(groups), index_(0) {}
+
+  void operator()(const PermissionsList::value_type& item) {
+    using namespace smart_objects;
+    using namespace policy;
+    groups_[index_] = SmartObject(SmartType_Map);
+
+    SmartObject& group = groups_[index_];
+    group[strings::name] = item.group_alias;
+    group[strings::id] = item.group_id;
+    GroupConsent permission_state = item.state;
+    // If state undefined, 'allowed' parameter should be absent
+    if (kGroupUndefined != permission_state) {
+      group["allowed"] = kGroupAllowed == permission_state;
+    }
+    ++index_;
+  }
+
+ private:
+  smart_objects::SmartObject& groups_;
+  int32_t index_;
+};
+
+#ifdef EXTERNAL_PROPRIETARY_MODE
+struct ExternalConsentStatusAppender
+    : std::unary_function<void,
+                          const policy::ExternalConsentStatus::value_type&> {
+  ExternalConsentStatusAppender(smart_objects::SmartObject& status)
+      : status_(status), index_(0) {}
+
+  void operator()(const policy::ExternalConsentStatus::value_type& item) {
+    using namespace smart_objects;
+    using namespace policy;
+    using namespace hmi_apis;
+    status_[index_] = SmartObject(SmartType_Map);
+
+    SmartObject& external_consent_status = status_[index_];
+    external_consent_status["entityType"] = item.entity_type;
+    external_consent_status["entityID"] = item.entity_id;
+    external_consent_status["status"] =
+        0 == strcasecmp("ON", item.entity_status.c_str())
+            ? static_cast<int32_t>(Common_EntityStatus::ON)
+            : static_cast<int32_t>(Common_EntityStatus::OFF);
+    ++index_;
+  }
+
+ private:
+  smart_objects::SmartObject& status_;
+  int32_t index_;
+};
+#endif  // EXTERNAL_PROPRIETARY_MODE
+
+} // namespace
+
 std::pair<std::string, VehicleDataType> kVehicleDataInitializer[] = {
     std::make_pair(strings::gps, VehicleDataType::GPS),
     std::make_pair(strings::speed, VehicleDataType::SPEED),
diff --git a/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc b/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
index 7b5954a3c3..5ec184e563 100644
--- a/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
+++ b/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
@@ -46,7 +46,8 @@ AppPermissionDelegate::AppPermissionDelegate(
 
 void AppPermissionDelegate::threadMain() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy_handler_.OnAppPermissionConsentInternal(connection_key_, permissions_);
+  policy_handler_.OnAppPermissionConsentInternal(
+      connection_key_, ccs_status_, permissions_);
 }
 
 void AppPermissionDelegate::exitThreadMain() {
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index a36df1f296..6c12edfbf4 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -35,6 +35,7 @@
 #include <algorithm>
 #include <vector>
 #include <functional>
+#include <utility>
 #include "application_manager/smart_object_keys.h"
 
 #include "application_manager/policies/delegates/app_permission_delegate.h"
@@ -204,13 +205,16 @@ struct SDLAllowedNotification {
   StateController& state_controller_;
 };
 
-struct LinkAppToDevice {
-  explicit LinkAppToDevice(
-      std::map<std::string, std::string>& app_to_device_link,
-      const ApplicationManager& application_manager)
-      : app_to_device_link_(app_to_device_link)
-      , application_manager_(application_manager) {
-    app_to_device_link_.clear();
+/**
+ * @brief Gets from system list of currently registered applications and
+ * create collection of links device-to-application
+ */
+struct LinksCollector {
+  LinksCollector(const ApplicationManager& application_manager,
+                 ApplicationsLinks& out_app_to_device_link)
+      : application_manager_(application_manager)
+      , out_app_to_device_link_(out_app_to_device_link) {
+    out_app_to_device_link_.clear();
   }
 
   void operator()(const ApplicationSharedPtr& app) {
@@ -229,12 +233,13 @@ struct LinkAppToDevice {
                    "Couldn't find device, which hosts application " << app_id);
       return;
     }
-    app_to_device_link_[app_id] = device_params.device_mac_address;
+    out_app_to_device_link_.insert(
+        std::make_pair(device_params.device_mac_address, app_id));
   }
 
  private:
-  std::map<std::string, std::string>& app_to_device_link_;
   const ApplicationManager& application_manager_;
+  ApplicationsLinks& out_app_to_device_link_;
 };
 
 /**
@@ -548,68 +553,67 @@ void PolicyHandler::SetDeviceInfo(const std::string& device_id,
 }
 
 void PolicyHandler::OnAppPermissionConsentInternal(
-    const uint32_t connection_key, PermissionConsent& permissions) {
+    const uint32_t connection_key,
+    const CCSStatus& ccs_status,
+    PermissionConsent& out_permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
+
   if (connection_key) {
     ApplicationSharedPtr app = application_manager_.application(connection_key);
 
     if (app.valid()) {
-      permissions.policy_app_id = app->policy_app_id();
+      out_permissions.policy_app_id = app->policy_app_id();
       DeviceParams device_params = GetDeviceParams(
           app->device(),
           application_manager_.connection_handler().get_session_observer());
 
-      permissions.device_id = device_params.device_mac_address;
+      out_permissions.device_id = device_params.device_mac_address;
     }
 
-    if (!permissions.policy_app_id.empty()) {
-      policy_manager_->SetUserConsentForApp(permissions);
+    if (!out_permissions.policy_app_id.empty()) {
+      policy_manager_->SetUserConsentForApp(out_permissions);
     }
+  } else if (!app_to_device_link_.empty()) {
+    sync_primitives::AutoLock lock(app_to_device_link_lock_);
+    ApplicationsLinks::const_iterator it = app_to_device_link_.begin();
+    for (; app_to_device_link_.end() != it; ++it) {
+      ApplicationSharedPtr app =
+          application_manager_.application_by_policy_id(it->second);
+
+      // If list of apps sent to HMI for user consents is not the same as
+      // current,
+      // permissions should be set only for coincident to registered apps
+      if (!app.valid()) {
+        LOG4CXX_WARN(logger_,
+                     "Invalid pointer to application was passed."
+                     "Permissions setting skipped.");
+        continue;
+      }
 
-    return;
-  }
+      DeviceParams device_params = GetDeviceParams(
+          app->device(),
+          application_manager_.connection_handler().get_session_observer());
 
-  LinkAppsToDevice();
+      if (device_params.device_mac_address != it->first) {
+        LOG4CXX_WARN(logger_,
+                     "Device_id of application is changed."
+                     "Permissions setting skipped.");
+        continue;
+      }
 
-  if (!app_to_device_link_.size()) {
+      out_permissions.policy_app_id = it->second;
+      out_permissions.device_id = it->first;
+      policy_manager_->SetUserConsentForApp(out_permissions);
+    }
+  } else {
     LOG4CXX_WARN(logger_,
                  "There are no applications previously stored for "
                  "setting common permissions.");
-    return;
   }
 
-  std::map<std::string, std::string>::const_iterator it =
-      app_to_device_link_.begin();
-  std::map<std::string, std::string>::const_iterator it_end =
-      app_to_device_link_.end();
-  for (; it != it_end; ++it) {
-    ApplicationSharedPtr app =
-        application_manager_.application_by_policy_id(it->first);
-
-    // If list of apps sent to HMI for user consents is not the same as current,
-    // permissions should be set only for coincident to registered apps
-    if (!app.valid()) {
-      LOG4CXX_WARN(logger_,
-                   "Invalid pointer to application was passed."
-                   "Permissions setting skipped.");
-      continue;
-    }
-
-    DeviceParams device_params = GetDeviceParams(
-        app->device(),
-        application_manager_.connection_handler().get_session_observer());
-
-    if (device_params.device_mac_address != it->second) {
-      LOG4CXX_WARN(logger_,
-                   "Device_id of application is changed."
-                   "Permissions setting skipped.");
-      continue;
-    }
-
-    permissions.policy_app_id = it->first;
-    permissions.device_id = it->second;
-    policy_manager_->SetUserConsentForApp(permissions);
+  if (!policy_manager_->SetCCSStatus(ccs_status)) {
+    LOG4CXX_WARN(logger_, "CCS status has not been set!");
   }
 }
 
@@ -651,8 +655,7 @@ void PolicyHandler::OnGetUserFriendlyMessage(
       result, correlation_id, application_manager_);
 }
 
-void PolicyHandler::GetRegisteredLinks(
-    std::map<std::string, std::string>& out_links) const {
+void PolicyHandler::GetRegisteredLinks(ApplicationsLinks& out_links) const {
   DataAccessor<ApplicationSet> accessor = application_manager_.applications();
   ApplicationSetConstIt it_app = accessor.GetData().begin();
   ApplicationSetConstIt it_app_end = accessor.GetData().end();
@@ -661,30 +664,23 @@ void PolicyHandler::GetRegisteredLinks(
   std::for_each(it_app, it_app_end, linker);
 }
 
-void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
-                                           const uint32_t correlation_id) {
+std::vector<policy::FunctionalGroupPermission>
+PolicyHandler::CollectRegisteredAppsPermissions() {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
   // If no specific app was passed, get permissions for all currently registered
   // applications
-  if (!connection_key) {
-    LinkAppsToDevice();
-    PermissionsConsolidator consolidator;
-    std::vector<policy::FunctionalGroupPermission> group_permissions;
-    std::map<std::string, std::string>::const_iterator it =
-        app_to_device_link_.begin();
-    for (; it != app_to_device_link_.end(); ++it) {
-      policy_manager_->GetUserConsentForApp(
-          it->second, it->first, group_permissions);
-      consolidator.Consolidate(group_permissions);
-    }
+  sync_primitives::AutoLock lock(app_to_device_link_lock_);
 
-    MessageHelper::SendGetListOfPermissionsResponse(
-        consolidator.GetConsolidatedPermissions(),
-        correlation_id,
-        application_manager_);
+  GetRegisteredLinks(app_to_device_link_);
 
-    return;
+  PermissionsConsolidator consolidator;
+  std::vector<policy::FunctionalGroupPermission> group_permissions;
+  ApplicationsLinks::const_iterator it = app_to_device_link_.begin();
+  for (; it != app_to_device_link_.end(); ++it) {
+    policy_manager_->GetUserConsentForApp(
+        it->first, it->second, group_permissions);
+    consolidator.Consolidate(group_permissions);
   }
 
   // Single app only
@@ -825,6 +821,12 @@ std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired(
   return device_params.device_mac_address;
 }
 
+ApplicationsLinks PolicyHandler::GetRegisteredLinks() const {
+  ApplicationsLinks links;
+  GetRegisteredLinks(links);
+  return links;
+}
+
 void PolicyHandler::OnSystemInfoChanged(const std::string& language) {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
diff --git a/src/components/application_manager/src/smart_object_keys.cc b/src/components/application_manager/src/smart_object_keys.cc
index a470bba4dc..9ab79791a5 100644
--- a/src/components/application_manager/src/smart_object_keys.cc
+++ b/src/components/application_manager/src/smart_object_keys.cc
@@ -277,6 +277,22 @@ const char* is_suscribed = "isSubscribed";
 const char* message_data = "messageData";
 
 const char* delivery_mode = "deliveryMode";
+
+const char* audio_streaming_indicator = "audioStreamingIndicator";
+
+const char* const keyboard_properties_supported = "keyboardPropertiesSupported";
+const char* const language_supported = "languageSupported";
+const char* const keyboard_layout_supported = "keyboardLayoutSupported";
+const char* const keypress_mode_supported = "keypressModeSupported";
+const char* const limited_characters_list_supported =
+    "limitedCharactersListSupported";
+const char* const auto_complete_text_supported = "autoCompleteTextSupported";
+const char* const entity_type = "entityType";
+const char* const entity_id = "entityID";
+const char* const status = "status";
+const char* const ccs_status = "ccsStatus";
+const char* const consented_functions = "consentedFunctions";
+const char* const source = "source";
 }  // namespace strings
 
 namespace json {
diff --git a/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc b/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
index 4a9aa4a771..f3cca144b8 100644
--- a/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
+++ b/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
@@ -34,80 +34,7 @@
 #include <string>
 #include <vector>
 #include "gtest/gtest.h"
-#include "application_manager/commands/commands_test.h"
-
-#include "application_manager/commands/hmi/on_button_event_notification.h"
-#include "application_manager/commands/hmi/on_navi_tbt_client_state_notification.h"
-#include "application_manager/commands/hmi/on_navi_way_point_change_notification.h"
-#include "application_manager/commands/hmi/on_ui_command_notification.h"
-#include "application_manager/commands/hmi/on_ui_keyboard_input_notification.h"
-#include "application_manager/commands/hmi/on_ui_touch_event_notification.h"
-#include "application_manager/commands/hmi/on_vi_acc_pedal_position_notification.h"
-#include "application_manager/commands/hmi/on_vi_belt_status_notification.h"
-#include "application_manager/commands/hmi/on_vi_body_information_notification.h"
-#include "application_manager/commands/hmi/on_vi_device_status_notification.h"
-#include "application_manager/commands/hmi/on_vi_driver_braking_notification.h"
-#include "application_manager/commands/hmi/on_vi_engine_torque_notification.h"
-#include "application_manager/commands/hmi/on_vi_external_temperature_notification.h"
-#include "application_manager/commands/hmi/on_vi_fuel_level_notification.h"
-#include "application_manager/commands/hmi/on_vi_fuel_level_state_notification.h"
-#include "application_manager/commands/hmi/on_vi_gps_data_notification.h"
-#include "application_manager/commands/hmi/on_vi_head_lamp_status_notification.h"
-#include "application_manager/commands/hmi/on_vi_instant_fuel_consumption_notification.h"
-#include "application_manager/commands/hmi/on_vi_my_key_notification.h"
-#include "application_manager/commands/hmi/on_vi_odometer_notification.h"
-#include "application_manager/commands/hmi/on_vi_prndl_notification.h"
-#include "application_manager/commands/hmi/on_vi_rpm_notification.h"
-#include "application_manager/commands/hmi/on_vi_speed_notification.h"
-#include "application_manager/commands/hmi/on_vi_steering_wheel_angle_notification.h"
-#include "application_manager/commands/hmi/on_vi_tire_pressure_notification.h"
-#include "application_manager/commands/hmi/on_vi_vehicle_data_notification.h"
-#include "application_manager/commands/hmi/on_vi_vin_notification.h"
-#include "application_manager/commands/hmi/on_vi_wiper_status_notification.h"
-#include "application_manager/commands/hmi/on_app_permission_changed_notification.h"
-#include "application_manager/commands/hmi/on_app_registered_notification.h"
-#include "application_manager/commands/hmi/on_audio_data_streaming_notification.h"
-#include "application_manager/commands/hmi/on_button_subscription_notification.h"
-#include "application_manager/commands/hmi/on_file_removed_notification.h"
-#include "application_manager/commands/hmi/on_put_file_notification.h"
-#include "application_manager/commands/hmi/on_resume_audio_source_notification.h"
-#include "application_manager/commands/hmi/on_sdl_close_notification.h"
-#include "application_manager/commands/hmi/on_sdl_consent_needed_notification.h"
-#include "application_manager/commands/hmi/on_sdl_persistence_complete_notification.h"
-#include "application_manager/commands/hmi/on_status_update_notification.h"
-#include "application_manager/commands/hmi/on_video_data_streaming_notification.h"
-#include "application_manager/commands/hmi/on_record_start_notification.h"
-#include "application_manager/commands/hmi/on_app_activated_notification.h"
-#include "application_manager/commands/hmi/on_app_deactivated_notification.h"
-#include "application_manager/commands/hmi/on_app_unregistered_notification.h"
-#include "application_manager/commands/hmi/on_button_press_notification.h"
-#include "application_manager/commands/hmi/on_event_changed_notification.h"
-#include "application_manager/commands/hmi/on_ready_notification.h"
-#include "application_manager/commands/hmi/on_tts_reset_timeout_notification.h"
-#include "application_manager/commands/hmi/on_tts_started_notification.h"
-#include "application_manager/commands/hmi/on_tts_stopped_notification.h"
-#include "application_manager/commands/hmi/on_ui_reset_timeout_notification.h"
-#include "application_manager/commands/hmi/on_vr_started_notification.h"
-#include "application_manager/commands/hmi/on_vr_stopped_notification.h"
-#include "application_manager/commands/hmi/on_app_permission_consent_notification.h"
-#include "application_manager/commands/hmi/on_ignition_cycle_over_notification.h"
-#include "application_manager/commands/hmi/on_policy_update.h"
-#include "application_manager/commands/hmi/on_received_policy_update.h"
-#include "application_manager/commands/hmi/on_system_error_notification.h"
-#include "application_manager/commands/hmi/on_system_info_changed_notification.h"
-#include "application_manager/commands/hmi/on_allow_sdl_functionality_notification.h"
-#include "application_manager/commands/hmi/on_device_state_changed_notification.h"
-#include "application_manager/commands/hmi/on_exit_all_applications_notification.h"
-#include "application_manager/commands/hmi/on_exit_application_notification.h"
-#include "application_manager/commands/hmi/on_vr_command_notification.h"
-#include "application_manager/commands/hmi/on_vr_language_change_notification.h"
-#include "application_manager/commands/hmi/on_start_device_discovery.h"
-#include "application_manager/commands/hmi/on_device_chosen_notification.h"
-#include "application_manager/commands/hmi/on_system_context_notification.h"
-#include "application_manager/commands/hmi/on_system_request_notification.h"
-#include "application_manager/commands/hmi/on_tts_language_change_notification.h"
-#include "application_manager/commands/hmi/on_ui_language_change_notification.h"
-#include "application_manager/commands/hmi/on_driver_distraction_notification.h"
+#include "commands/command_request_test.h"
 
 #include "utils/lock.h"
 #include "utils/data_accessor.h"
@@ -116,6 +43,7 @@
 #include "utils/make_shared.h"
 #include "utils/file_system.h"
 #include "smart_objects/smart_object.h"
+#include "interfaces/HMI_API.h"
 #include "application_manager/smart_object_keys.h"
 #include "application_manager/mock_application_manager.h"
 #include "application_manager/mock_state_controller.h"
@@ -127,13 +55,85 @@
 #include "connection_handler/mock_connection_handler.h"
 #include "connection_handler/mock_connection_handler_settings.h"
 #include "test/application_manager/mock_application_manager_settings.h"
-#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/mock_policy_handler_interface.h"
 #include "application_manager/mock_message_helper.h"
-#include "protocol_handler/mock_session_observer.h"
 
-namespace am = application_manager;
-
-static am::MockMessageHelper* message_helper_mock_;
+#ifdef HMI_DBUS_API
+#include "hmi/on_vi_acc_pedal_position_notification.h"
+#include "hmi/on_vi_belt_status_notification.h"
+#include "hmi/on_vi_body_information_notification.h"
+#include "hmi/on_vi_device_status_notification.h"
+#include "hmi/on_vi_driver_braking_notification.h"
+#include "hmi/on_vi_engine_torque_notification.h"
+#include "hmi/on_vi_external_temperature_notification.h"
+#include "hmi/on_vi_fuel_level_notification.h"
+#include "hmi/on_vi_fuel_level_state_notification.h"
+#include "hmi/on_vi_gps_data_notification.h"
+#include "hmi/on_vi_head_lamp_status_notification.h"
+#include "hmi/on_vi_instant_fuel_consumption_notification.h"
+#include "hmi/on_vi_my_key_notification.h"
+#include "hmi/on_vi_odometer_notification.h"
+#include "hmi/on_vi_prndl_notification.h"
+#include "hmi/on_vi_rpm_notification.h"
+#include "hmi/on_vi_speed_notification.h"
+#include "hmi/on_vi_steering_wheel_angle_notification.h"
+#include "hmi/on_vi_tire_pressure_notification.h"
+#include "hmi/on_vi_vin_notification.h"
+#include "hmi/on_vi_wiper_status_notification.h"
+#else
+#include "hmi/on_vi_vehicle_data_notification.h"
+#endif  // HMI_DBUS_API
+
+#include "hmi/on_button_event_notification.h"
+#include "hmi/on_navi_tbt_client_state_notification.h"
+#include "hmi/on_navi_way_point_change_notification.h"
+#include "hmi/on_ui_command_notification.h"
+#include "hmi/on_ui_keyboard_input_notification.h"
+#include "hmi/on_ui_touch_event_notification.h"
+#include "hmi/on_app_permission_changed_notification.h"
+#include "hmi/on_app_registered_notification.h"
+#include "hmi/on_audio_data_streaming_notification.h"
+#include "hmi/on_button_subscription_notification.h"
+#include "hmi/on_file_removed_notification.h"
+#include "hmi/on_put_file_notification.h"
+#include "hmi/on_resume_audio_source_notification.h"
+#include "hmi/on_sdl_close_notification.h"
+#include "hmi/on_sdl_consent_needed_notification.h"
+#include "hmi/on_sdl_persistence_complete_notification.h"
+#include "hmi/on_status_update_notification.h"
+#include "hmi/on_video_data_streaming_notification.h"
+#include "hmi/on_record_start_notification.h"
+#include "hmi/on_app_activated_notification.h"
+#include "hmi/on_app_deactivated_notification.h"
+#include "hmi/on_app_unregistered_notification.h"
+#include "hmi/on_button_press_notification.h"
+#include "hmi/on_event_changed_notification.h"
+#include "hmi/on_ready_notification.h"
+#include "hmi/on_tts_reset_timeout_notification.h"
+#include "hmi/on_tts_started_notification.h"
+#include "hmi/on_tts_stopped_notification.h"
+#include "hmi/on_ui_reset_timeout_notification.h"
+#include "hmi/on_vr_started_notification.h"
+#include "hmi/on_vr_stopped_notification.h"
+#include "hmi/on_app_permission_consent_notification.h"
+#include "hmi/on_ignition_cycle_over_notification.h"
+#include "hmi/on_policy_update.h"
+#include "hmi/on_received_policy_update.h"
+#include "hmi/on_system_error_notification.h"
+#include "hmi/on_system_info_changed_notification.h"
+#include "hmi/on_allow_sdl_functionality_notification.h"
+#include "hmi/on_device_state_changed_notification.h"
+#include "hmi/on_exit_all_applications_notification.h"
+#include "hmi/on_exit_application_notification.h"
+#include "hmi/on_vr_command_notification.h"
+#include "hmi/on_vr_language_change_notification.h"
+#include "hmi/on_start_device_discovery.h"
+#include "hmi/on_device_chosen_notification.h"
+#include "hmi/on_system_context_notification.h"
+#include "hmi/on_system_request_notification.h"
+#include "hmi/on_tts_language_change_notification.h"
+#include "hmi/on_ui_language_change_notification.h"
+#include "hmi/on_device_connection_status_notification.h"
 
 namespace test {
 namespace components {
@@ -141,45 +141,34 @@ namespace commands_test {
 namespace hmi_commands_test {
 namespace hmi_notifications_test {
 
+namespace am = application_manager;
+
 using ::testing::_;
 using ::testing::Test;
 using ::testing::Types;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::NiceMock;
-using ::testing::Mock;
-using ::testing::InSequence;
 using ::utils::SharedPtr;
 using ::smart_objects::SmartObject;
-using ::application_manager::commands::MessageSharedPtr;
-using ::test::components::application_manager_test::MockApplicationManager;
-using ::test::components::application_manager_test::
-    MockApplicationManagerSettings;
-using ::application_manager::ApplicationSharedPtr;
-using ::test::components::application_manager_test::MockApplication;
-using ::test::components::event_engine_test::MockEventDispatcher;
-using ::application_manager::MockMessageHelper;
+using testing::Mock;
 
-using namespace am::commands;
+namespace am = ::application_manager;
+namespace strings = am::strings;
 
-typedef SharedPtr<MockApplication> MockAppPtr;
-typedef NiceMock<
-    ::test::components::application_manager_test::MockHMICapabilities>
-    MockHMICapabilities;
+using am::commands::MessageSharedPtr;
+using am::ApplicationSharedPtr;
 
-#define MEDIA true
-#define NOT_MEDIA false
-#define VC true
-#define NOT_VC false
-#define NAVI true
-#define NOT_NAVI false
+using namespace am::commands;
 
 ACTION_P(GetEventId, event_id) {
   *event_id = arg0.id();
 }
+
 ACTION_P(GetArg, arg) {
   *arg = arg0;
 }
+
 ACTION_P2(GetConnectIdPermissionConsent, connect_id, consent) {
   *connect_id = arg0;
   std::vector<policy::FunctionalGroupPermission>::const_iterator it =
@@ -189,20 +178,14 @@ ACTION_P2(GetConnectIdPermissionConsent, connect_id, consent) {
   }
   consent->consent_source = arg1.consent_source;
 }
+
 ACTION_P2(GetBoolValueAndString, value, str) {
   *value = arg0;
   *str = arg1;
 }
+
 ACTION_P(GetMessage, message) {
-  (*message)[am::strings::params][am::strings::function_id] =
-      (*arg0)[am::strings::params][am::strings::function_id].asInt();
-  (*message)[am::strings::params][am::strings::message_type] =
-      (*arg0)[am::strings::params][am::strings::message_type].asInt();
-  (*message)[am::strings::params][am::strings::correlation_id] =
-      (*arg0)[am::strings::params][am::strings::correlation_id].asInt();
-  (*message)[am::strings::params][am::strings::connection_key] =
-      (*arg0)[am::strings::params][am::strings::connection_key].asInt();
-  return (*message)[am::strings::params][am::strings::correlation_id].asInt();
+  (*message) = (*arg0);
 }
 
 namespace {
@@ -212,118 +195,77 @@ const int32_t kHmiProtocolType_ = 1;
 const int32_t kMobileProtocolType_ = 0;
 const int32_t kProtocolVersion_ = 3;
 const uint32_t kCorrelationId_ = 1939u;
-const uint32_t kAppId_ = 2014u;
+const uint32_t kAppId = 2014u;
+const uint32_t kConnectionKey = 0u;
+// Following variable represents MAC adress so it must contain 12 symbols.
+const std::string kCustomDeviceInternalId = "255255255001";
+const std::string kEmptyDeviceInternalId = "";
+const std::string kDeviceId = "device_id";
 }  // namespace
 
 class HMICommandsNotificationsTest
-    : public components::commands_test::CommandsTest<
+    : public components::commands_test::CommandRequestTest<
           CommandsTestMocks::kIsNice> {
  public:
   HMICommandsNotificationsTest()
-      : applications_(application_set_, applications_lock_), app_ptr_(NULL) {
-    message_helper_mock_ =
-        application_manager::MockMessageHelper::message_helper_mock();
-    Mock::VerifyAndClearExpectations(message_helper_mock_);
-  }
+      : mock_app_(CreateMockApp())
+      , message_helper_mock_(NULL)
+      , message_(CreateMessage(smart_objects::SmartType_Map))
+      , applications_(application_set_, applications_lock_) {}
 
-  ~HMICommandsNotificationsTest() {
-    // Fix DataAccessor release and WinQt crash
-    Mock::VerifyAndClearExpectations(&app_mngr_);
-    Mock::VerifyAndClearExpectations(message_helper_mock_);
-  }
   typedef Command CommandType;
 
- protected:
+  MockAppPtr mock_app_;
+  am::MockMessageHelper* message_helper_mock_;
+
+  MessageSharedPtr message_;
   am::ApplicationSet application_set_;
   sync_primitives::Lock applications_lock_;
   DataAccessor<am::ApplicationSet> applications_;
-  MockHMICapabilities mock_hmi_capabilities_;
-
-  NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
-  NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_;
+  NiceMock<application_manager_test::MockHMICapabilities>
+      mock_hmi_capabilities_;
 
-  application_manager_test::MockStateController mock_state_controller_;
+  typename IsNiceMock<policy_test::MockPolicyHandlerInterface,
+                      kAreMocksNice>::Result mock_policy_handler_;
 
-  am::ApplicationSharedPtr app_;
-  NiceMock<MockApplication>* app_ptr_;
+  typename IsNiceMock<application_manager_test::MockStateController,
+                      kAreMocksNice>::Result mock_state_controller_;
 
-  typedef IsNiceMock<connection_handler_test::MockConnectionHandler,
-                     kMocksAreNice>::Result MockConnectionHandler;
-
-  typedef IsNiceMock<protocol_handler_test::MockSessionObserver,
-                     kMocksAreNice>::Result MockSessionObserver;
-
-  MockConnectionHandler mock_connection_handler_;
-  MockSessionObserver mock_session_observer_;
-
-  void InitCommand(const uint32_t& default_timeout) OVERRIDE {
-    app_ = ConfigureApp(&app_ptr_, kAppId_, NOT_MEDIA, NOT_NAVI, NOT_VC);
-    EXPECT_CALL(app_mngr_, get_settings())
-        .WillOnce(ReturnRef(app_mngr_settings_));
-    EXPECT_CALL(app_mngr_settings_, default_timeout())
-        .WillOnce(ReturnRef(default_timeout));
-    ON_CALL(app_mngr_, event_dispatcher())
-        .WillByDefault(ReturnRef(mock_event_dispatcher_));
-    ON_CALL(app_mngr_, GetPolicyHandler())
-        .WillByDefault(ReturnRef(policy_interface_));
-    ON_CALL(app_mngr_, application_by_hmi_app(_)).WillByDefault(Return(app_));
-    ON_CALL(*app_ptr_, app_id()).WillByDefault(Return(kAppId_));
+ protected:
+  void SetUp() OVERRIDE {
+    message_helper_mock_ = am::MockMessageHelper::message_helper_mock();
+    Mock::VerifyAndClearExpectations(&message_helper_mock_);
+    ConfigureApp(kAppId, false, false, false);
+    ON_CALL(mock_app_manager_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    ON_CALL(mock_app_manager_, application_by_hmi_app(_))
+        .WillByDefault(Return(mock_app_));
   }
 
-  am::ApplicationSharedPtr ConfigureApp(NiceMock<MockApplication>** app_mock,
-                                        uint32_t app_id,
-                                        bool media,
-                                        bool navi,
-                                        bool vc) {
-    *app_mock = new NiceMock<MockApplication>;
-
-    Mock::AllowLeak(*app_mock);  // WorkAround for gogletest bug
-    am::ApplicationSharedPtr app(*app_mock);
-
-    ON_CALL(**app_mock, app_id()).WillByDefault(Return(app_id));
-    ON_CALL(**app_mock, is_media_application()).WillByDefault(Return(media));
-    ON_CALL(**app_mock, is_navi()).WillByDefault(Return(navi));
-    ON_CALL(**app_mock, is_voice_communication_supported())
-        .WillByDefault(Return(vc));
-    ON_CALL(**app_mock, IsAudioApplication())
-        .WillByDefault(Return(media || navi || vc));
-    return app;
+  void TearDown() OVERRIDE {
+    Mock::VerifyAndClearExpectations(&message_helper_mock_);
+    Mock::VerifyAndClearExpectations(&mock_app_manager_);
   }
-#if defined(OS_POSIX)
-  void SubscribeForSignal() {
-    sigset_t signal_set;
-    sigemptyset(&signal_set);
-    sigaddset(&signal_set, SIGINT);
-    sigaddset(&signal_set, SIGTERM);
-    pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
-  }
-#endif
-};
 
-namespace {
-void sig_handler(int sig) {
-  switch (sig) {
-    case SIGINT:
-      break;
-    case SIGTERM:
-      break;
-    case SIGSEGV:
-      abort();
-    default:
-      exit(EXIT_FAILURE);
+  void ConfigureApp(uint32_t app_id, bool media, bool navi, bool vc) {
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(app_id));
+    ON_CALL(*mock_app_, is_media()).WillByDefault(Return(media));
+    ON_CALL(*mock_app_, is_navi()).WillByDefault(Return(navi));
+    ON_CALL(*mock_app_, is_voice_communication()).WillByDefault(Return(vc));
+    ON_CALL(*mock_app_, is_audio()).WillByDefault(Return(media || navi || vc));
   }
-}
-}  //  namespace
+};
 
 template <class Command>
-class HMIOnViNotifications : public commands_test::CommandsTest<kIsNice> {
+class HMIOnViNotifications
+    : public commands_test::CommandsTest<CommandsTestMocks::kIsNice> {
  public:
   typedef Command CommandType;
 };
 
 template <class Command>
 class HMIOnNotificationsListToHMI
-    : public commands_test::CommandsTest<kIsNice> {
+    : public commands_test::CommandsTest<CommandsTestMocks::kIsNice> {
  public:
   typedef Command CommandType;
 };
@@ -336,34 +278,38 @@ struct CommandPair {
 
 template <class Command>
 class HMIOnNotificationsEventDispatcher
-    : public commands_test::CommandsTest<kIsNice> {
+    : public commands_test::CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
   typedef Command CommandType;
-  NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
 };
 
-typedef Types<OnVIAccPedalPositionNotification,
-              OnVIBeltStatusNotification,
-              OnVIBodyInformationNotification,
-              OnVIDeviceStatusNotification,
-              OnVIDriverBrakingNotification,
-              OnVIEngineTorqueNotification,
-              OnVIExternalTemperatureNotification,
-              OnVIFuelLevelNotification,
-              OnVIFuelLevelStateNotification,
-              OnVIGpsDataNotification,
-              OnVIHeadLampStatusNotification,
-              OnVIInstantFuelConsumptionNotification,
-              OnVIMyKeyNotification,
-              OnVIOdometerNotification,
-              OnVIPrndlNotification,
-              OnVIRpmNotification,
-              OnVISpeedNotification,
-              OnVISteeringWheelAngleNotification,
-              OnVITirePressureNotification,
-              OnVIVehicleDataNotification,
-              OnVIVinNotification,
-              OnVIWiperStatusNotification> HMIOnViNotificationsTypes;
+typedef Types<
+#ifdef HMI_DBUS_API
+    OnVIAccPedalPositionNotification,
+    OnVIBeltStatusNotification,
+    OnVIBodyInformationNotification,
+    OnVIDeviceStatusNotification,
+    OnVIDriverBrakingNotification,
+    OnVIEngineTorqueNotification,
+    OnVIExternalTemperatureNotification,
+    OnVIFuelLevelNotification,
+    OnVIFuelLevelStateNotification,
+    OnVIGpsDataNotification,
+    OnVIHeadLampStatusNotification,
+    OnVIInstantFuelConsumptionNotification,
+    OnVIMyKeyNotification,
+    OnVIOdometerNotification,
+    OnVIPrndlNotification,
+    OnVIRpmNotification,
+    OnVISpeedNotification,
+    OnVISteeringWheelAngleNotification,
+    OnVITirePressureNotification,
+    OnVIVinNotification,
+    OnVIWiperStatusNotification
+#else
+    OnVIVehicleDataNotification
+#endif  // HMI_DBUS_API
+    > HMIOnViNotificationsTypes;
 
 typedef Types<OnAppPermissionChangedNotification,
               OnAudioDataStreamingNotification,
@@ -376,7 +322,8 @@ typedef Types<OnAppPermissionChangedNotification,
               OnSDLPersistenceCompleteNotification,
               OnStatusUpdateNotification,
               OnVideoDataStreamingNotification,
-              OnRecordStartdNotification> HMIOnNotificationsListToHMITypes;
+              OnRecordStartdNotification,
+              OnAppRegisteredNotification> HMIOnNotificationsListToHMITypes;
 
 typedef Types<
     CommandPair<OnAppActivatedNotification,
@@ -401,45 +348,43 @@ TYPED_TEST_CASE(HMIOnNotificationsEventDispatcher,
                 HMIOnNotificationsEventDispatcherTypes);
 
 TYPED_TEST(HMIOnViNotifications, CommandsSendNotificationToMobile) {
-  MessageSharedPtr message =
-      commands_test::CommandsTest<kIsNice>::CreateMessage();
+  MessageSharedPtr message = this->CreateMessage();
   utils::SharedPtr<typename TestFixture::CommandType> command =
       this->template CreateCommand<typename TestFixture::CommandType>(message);
-  EXPECT_CALL(commands_test::CommandsTest<kIsNice>::app_mngr_,
+  EXPECT_CALL(commands_test::CommandsTest<
+                  CommandsTestMocks::kIsNice>::mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(
       static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID),
-      (*message)[am::strings::params][am::strings::function_id].asInt());
+      (*message)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message)[strings::params][strings::message_type].asInt());
 }
 
 TYPED_TEST(HMIOnNotificationsListToHMI, CommandsSendNotificationToHmi) {
-  MessageSharedPtr message =
-      commands_test::CommandsTest<kIsNice>::CreateMessage();
+  MessageSharedPtr message = this->CreateMessage();
   utils::SharedPtr<typename TestFixture::CommandType> command =
       this->template CreateCommand<typename TestFixture::CommandType>(message);
-  EXPECT_CALL(commands_test::CommandsTest<kIsNice>::app_mngr_,
+  EXPECT_CALL(commands_test::CommandsTest<
+                  CommandsTestMocks::kIsNice>::mock_app_manager_,
               SendMessageToHMI(_));
   command->Run();
-  EXPECT_EQ(
-      static_cast<int32_t>(kHmiProtocolType_),
-      (*message)[am::strings::params][am::strings::protocol_type].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kProtocolVersion_),
-      (*message)[am::strings::params][am::strings::protocol_version].asInt());
+  EXPECT_EQ(static_cast<int32_t>(kHmiProtocolType_),
+            (*message)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(static_cast<int32_t>(kProtocolVersion_),
+            (*message)[strings::params][strings::protocol_version].asInt());
 }
 
 TYPED_TEST(HMIOnNotificationsEventDispatcher,
            CommandsNotificationEventDispatcher) {
   int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message =
-      commands_test::CommandsTest<kIsNice>::CreateMessage();
+  MessageSharedPtr message = this->CreateMessage();
   utils::SharedPtr<typename TestFixture::CommandType::CommandType> command =
       this->template CreateCommand<
           typename TestFixture::CommandType::CommandType>(message);
-  EXPECT_CALL(commands_test::CommandsTest<kIsNice>::app_mngr_,
+  EXPECT_CALL(commands_test::CommandsTest<
+                  CommandsTestMocks::kIsNice>::mock_app_manager_,
               event_dispatcher())
       .WillOnce(ReturnRef(this->mock_event_dispatcher_));
   EXPECT_CALL(this->mock_event_dispatcher_, raise_event(_))
@@ -448,196 +393,157 @@ TYPED_TEST(HMIOnNotificationsEventDispatcher,
   EXPECT_EQ(TestFixture::CommandType::kHMICommandId, event_id);
 }
 
-// notifications(SendNotificationToMobile)
 TEST_F(HMICommandsNotificationsTest, OnButtonEventSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnButtonEventNotification>(message);
+      CreateCommand<hmi::OnButtonEventNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnButtonEventID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnNaviTBTClientSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnNaviTBTClientStateNotification>(message);
+      CreateCommand<OnNaviTBTClientStateNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnTBTClientStateID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnNaviWayPointChangeSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnNaviWayPointChangeNotification>(message);
+      CreateCommand<OnNaviWayPointChangeNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnWayPointChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnUICommandSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnUICommandNotification>(message);
+      CreateCommand<OnUICommandNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::eType::OnCommandID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(mobile_apis::TriggerSource::TS_MENU),
-      (*message)[am::strings::msg_params][am::strings::trigger_source].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(static_cast<int32_t>(mobile_apis::TriggerSource::TS_MENU),
+            (*message_)[strings::msg_params][strings::trigger_source].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnUIKeyBoardInputSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnUIKeyBoardInputNotification>(message);
+      CreateCommand<hmi::OnUIKeyBoardInputNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnKeyboardInputID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnUITouchEventSendNotificationToMobile) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnUITouchEventNotification>(message);
+      CreateCommand<hmi::OnUITouchEventNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnTouchEventID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
-}
-
-TEST_F(HMICommandsNotificationsTest,
-       OnAppRegisteredNotificationSendNotificationToHmi) {
-  int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message = CreateMessage();
-  utils::SharedPtr<Command> command =
-      CreateCommand<OnAppRegisteredNotification>(message);
-
-  EXPECT_CALL(app_mngr_, SendMessageToHMI(_));
-  EXPECT_CALL(app_mngr_, event_dispatcher());
-  EXPECT_CALL(mock_event_dispatcher_, raise_event(_))
-      .WillOnce(GetEventId(&event_id));
-  command->Run();
-  EXPECT_EQ(static_cast<int32_t>(
-                hmi_apis::FunctionID::BasicCommunication_OnAppRegistered),
-            event_id);
-  EXPECT_EQ(
-      kHmiProtocolType_,
-      (*message)[am::strings::params][am::strings::protocol_type].asInt());
-  EXPECT_EQ(
-      kProtocolVersion_,
-      (*message)[am::strings::params][am::strings::protocol_version].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnAppUnregisteredNotificationEventDispatcher) {
   int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message = CreateMessage();
+
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAppUnregisteredNotification>(message);
+      CreateCommand<OnAppUnregisteredNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, SendMessageToHMI(_));
-  EXPECT_CALL(app_mngr_, event_dispatcher());
+  EXPECT_CALL(mock_app_manager_, SendMessageToHMI(_));
+  EXPECT_CALL(mock_app_manager_, event_dispatcher());
   EXPECT_CALL(mock_event_dispatcher_, raise_event(_))
       .WillOnce(GetEventId(&event_id));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(
                 hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered),
             event_id);
-  EXPECT_EQ(
-      kHmiProtocolType_,
-      (*message)[am::strings::params][am::strings::protocol_type].asInt());
-  EXPECT_EQ(
-      kProtocolVersion_,
-      (*message)[am::strings::params][am::strings::protocol_version].asInt());
+  EXPECT_EQ(kHmiProtocolType_,
+            (*message_)[strings::params][strings::protocol_type].asInt());
+  EXPECT_EQ(kProtocolVersion_,
+            (*message_)[strings::params][strings::protocol_version].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnButtonPressNotificationEventDispatcher) {
   int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message = CreateMessage();
+
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnButtonPressNotification>(message);
+      CreateCommand<hmi::OnButtonPressNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(app_mngr_, event_dispatcher());
+  EXPECT_CALL(mock_app_manager_, event_dispatcher());
   EXPECT_CALL(mock_event_dispatcher_, raise_event(_))
       .WillOnce(GetEventId(&event_id));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(hmi_apis::FunctionID::Buttons_OnButtonPress),
             event_id);
   EXPECT_EQ(static_cast<int>(mobile_apis::FunctionID::eType::OnButtonPressID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnReadyNotificationEventDispatcher) {
   int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message = CreateMessage();
+
   utils::SharedPtr<Command> command =
-      CreateCommand<OnReadyNotification>(message);
+      CreateCommand<OnReadyNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, OnHMIStartedCooperation());
-  EXPECT_CALL(app_mngr_, event_dispatcher());
+  EXPECT_CALL(mock_app_manager_, OnHMIStartedCooperation());
+  EXPECT_CALL(mock_app_manager_, event_dispatcher());
   EXPECT_CALL(mock_event_dispatcher_, raise_event(_))
       .WillOnce(GetEventId(&event_id));
   command->Run();
   EXPECT_EQ(hmi_apis::FunctionID::BasicCommunication_OnReady, event_id);
 }
 
-// policy handler
 TEST_F(HMICommandsNotificationsTest,
        OnIgnitionCycleOverNotificationPolicyHandler) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnIgnitionCycleOverNotification>(message);
+      CreateCommand<OnIgnitionCycleOverNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnIgnitionCycleOver());
+  EXPECT_CALL(mock_policy_handler_, OnIgnitionCycleOver());
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest, OnPolicyUpdateNotificationPolicyHandler) {
-  MessageSharedPtr message = CreateMessage();
-  utils::SharedPtr<Command> command = CreateCommand<OnPolicyUpdate>(message);
+  utils::SharedPtr<Command> command = CreateCommand<OnPolicyUpdate>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnPTExchangeNeeded());
+  EXPECT_CALL(mock_policy_handler_, OnPTExchangeNeeded());
   command->Run();
 }
 
-#if defined(PROPRIETARY_MODE) || defined(EXTERNAL_PROPRIETARY_MODE)
 TEST_F(HMICommandsNotificationsTest,
        OnReceivePolicyUpdateNotification_SUCCESS) {
   const std::string kFile = "./test_file.txt";
@@ -646,76 +552,67 @@ TEST_F(HMICommandsNotificationsTest,
   std::vector<uint8_t> data(tmp, tmp + 4);
   EXPECT_TRUE(file_system::WriteBinaryFile(kFile, data));
 
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_String);
-  (*message)[am::strings::msg_params][am::hmi_notification::policyfile] = kFile;
+  (*message_)[strings::msg_params][am::hmi_notification::policyfile] = kFile;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnReceivedPolicyUpdate>(message);
+      CreateCommand<OnReceivedPolicyUpdate>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, ReceiveMessageFromSDK(kFile, data));
+  EXPECT_CALL(mock_policy_handler_, ReceiveMessageFromSDK(kFile, data));
   command->Run();
   EXPECT_TRUE(file_system::DeleteFile(kFile));
 }
-#endif
 
 TEST_F(HMICommandsNotificationsTest,
        OnReceivePolicyUpdateNotification_UNSUCCESS) {
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_String);
   utils::SharedPtr<Command> command =
-      CreateCommand<OnReceivedPolicyUpdate>(message);
+      CreateCommand<OnReceivedPolicyUpdate>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler()).Times(0);
-  EXPECT_CALL(policy_interface_, ReceiveMessageFromSDK(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, GetPolicyHandler()).Times(0);
+  EXPECT_CALL(mock_policy_handler_, ReceiveMessageFromSDK(_, _)).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnAppPermissionConsentNotificationPolicyHandlerNoAppId) {
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_Map);
-  (*message)[am::strings::msg_params]["consentedFunctions"] =
+  (*message_)[strings::msg_params]["consentedFunctions"] =
       smart_objects::SmartObject(smart_objects::SmartType_Array);
   SmartObject& applications =
-      (*message)[am::strings::msg_params]["consentedFunctions"];
+      (*message_)[strings::msg_params]["consentedFunctions"];
 
   smart_objects::SmartObject hmi_application_temp(smart_objects::SmartType_Map);
   applications[0] = hmi_application_temp;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAppPermissionConsentNotification>(message);
-
-  int32_t connection_id = -1;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAppPermissionConsent(_, _))
-      .WillOnce(GetArg(&connection_id));
+      CreateCommand<OnAppPermissionConsentNotification>(message_);
+  EXPECT_CALL(mock_policy_handler_,
+              OnAppPermissionConsent(kConnectionKey, _, _));
   command->Run();
-  EXPECT_EQ(0, connection_id);
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnAppPermissionConsentNotificationPolicyHandlerWithAppId) {
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_Map);
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
-  (*message)[am::strings::msg_params]["consentedFunctions"] =
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params]["consentedFunctions"] =
       smart_objects::SmartObject(smart_objects::SmartType_Array);
 
   smart_objects::SmartObjectSPtr consented_function =
       utils::MakeShared<smart_objects::SmartObject>();
-  (*message)[am::strings::msg_params]["consentedFunctions"][0] =
+  (*message_)[strings::msg_params]["consentedFunctions"][0] =
       *consented_function;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAppPermissionConsentNotification>(message);
+      CreateCommand<OnAppPermissionConsentNotification>(message_);
 
-  int32_t connection_id = -1;
+  uint32_t connection_id = 0u;
   policy::PermissionConsent permission_consent;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAppPermissionConsent(_, _))
+  EXPECT_CALL(mock_policy_handler_, OnAppPermissionConsent(_, _, _))
       .WillOnce(
           GetConnectIdPermissionConsent(&connection_id, &permission_consent));
   command->Run();
-  EXPECT_EQ(static_cast<int32_t>(kAppId_), connection_id);
+  EXPECT_EQ(kAppId, connection_id);
+
   std::vector<policy::FunctionalGroupPermission>::const_iterator it =
       permission_consent.group_permissions.begin();
+
   for (; it != permission_consent.group_permissions.end(); ++it) {
     EXPECT_EQ(policy::kGroupUndefined, (*it).state);
   }
@@ -723,31 +620,29 @@ TEST_F(HMICommandsNotificationsTest,
 
 TEST_F(HMICommandsNotificationsTest,
        OnAppPermissionConsentNotificationPolicyHandlerAppIdAllowTrue) {
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_Map);
-  (*message)[am::strings::msg_params]["consentedFunctions"] =
+  (*message_)[strings::msg_params]["consentedFunctions"] =
       smart_objects::SmartObject(smart_objects::SmartType_Array);
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
-  (*message)[am::strings::msg_params]["source"] = "test_content_source";
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params]["source"] = "test_content_source";
 
   smart_objects::SmartObjectSPtr consented_function =
       utils::MakeShared<smart_objects::SmartObject>();
   (*consented_function)["allowed"] = true;
-  (*consented_function)[am::strings::id] = 999;
-  (*consented_function)[am::strings::name] = "test_group_alias";
-  (*message)[am::strings::msg_params]["consentedFunctions"][0] =
+  (*consented_function)[strings::id] = 999;
+  (*consented_function)[strings::name] = "test_group_alias";
+  (*message_)[strings::msg_params]["consentedFunctions"][0] =
       *consented_function;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAppPermissionConsentNotification>(message);
+      CreateCommand<OnAppPermissionConsentNotification>(message_);
 
-  int32_t connection_id = -1;
+  uint32_t connection_id = 0u;
   policy::PermissionConsent permission_consent;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAppPermissionConsent(_, _))
+  EXPECT_CALL(mock_policy_handler_, OnAppPermissionConsent(_, _, _))
       .WillOnce(
           GetConnectIdPermissionConsent(&connection_id, &permission_consent));
   command->Run();
-  EXPECT_EQ(static_cast<int32_t>(kAppId_), connection_id);
+  EXPECT_EQ(kAppId, connection_id);
 
   std::vector<policy::FunctionalGroupPermission>::const_iterator it =
       permission_consent.group_permissions.begin();
@@ -761,31 +656,29 @@ TEST_F(HMICommandsNotificationsTest,
 
 TEST_F(HMICommandsNotificationsTest,
        OnAppPermissionConsentNotificationPolicyHandlerAppIdAllowFalse) {
-  MessageSharedPtr message = CreateMessage(smart_objects::SmartType_Map);
-  (*message)[am::strings::msg_params]["consentedFunctions"] =
+  (*message_)[strings::msg_params]["consentedFunctions"] =
       smart_objects::SmartObject(smart_objects::SmartType_Array);
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
-  (*message)[am::strings::msg_params]["source"] = "test_content_source";
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params]["source"] = "test_content_source";
 
   smart_objects::SmartObjectSPtr consented_function =
       utils::MakeShared<smart_objects::SmartObject>();
   (*consented_function)["allowed"] = false;
-  (*consented_function)[am::strings::id] = 999;
-  (*consented_function)[am::strings::name] = "test_group_alias";
-  (*message)[am::strings::msg_params]["consentedFunctions"][0] =
+  (*consented_function)[strings::id] = 999;
+  (*consented_function)[strings::name] = "test_group_alias";
+  (*message_)[strings::msg_params]["consentedFunctions"][0] =
       *consented_function;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAppPermissionConsentNotification>(message);
+      CreateCommand<OnAppPermissionConsentNotification>(message_);
 
-  int32_t connection_id = -1;
+  uint32_t connection_id = 0u;
   policy::PermissionConsent permission_consent;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAppPermissionConsent(_, _))
+  EXPECT_CALL(mock_policy_handler_, OnAppPermissionConsent(_, _, _))
       .WillOnce(
           GetConnectIdPermissionConsent(&connection_id, &permission_consent));
   command->Run();
-  EXPECT_EQ(static_cast<int32_t>(kAppId_), connection_id);
+  EXPECT_EQ(kAppId, connection_id);
 
   std::vector<policy::FunctionalGroupPermission>::const_iterator it =
       permission_consent.group_permissions.begin();
@@ -799,16 +692,14 @@ TEST_F(HMICommandsNotificationsTest,
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemErrorNotificationOnSystemErrorCode) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::error] =
+  (*message_)[strings::msg_params][am::hmi_notification::error] =
       hmi_apis::Common_SystemError::SYNC_REBOOTED;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemErrorNotification>(message);
+      CreateCommand<OnSystemErrorNotification>(message_);
 
   int32_t code = hmi_apis::Common_SystemError::INVALID_ENUM;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnSystemError(_)).WillOnce(GetArg(&code));
+  EXPECT_CALL(mock_policy_handler_, OnSystemError(_)).WillOnce(GetArg(&code));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(hmi_apis::Common_SystemError::SYNC_REBOOTED),
             code);
@@ -817,49 +708,42 @@ TEST_F(HMICommandsNotificationsTest,
 TEST_F(HMICommandsNotificationsTest,
        OnSystemInfoChangedNotificationCheckLanguage) {
   const uint32_t kLangCode = 5u;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLangCode;
+
+  (*message_)[strings::msg_params][strings::language] = kLangCode;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemInfoChangedNotification>(message);
+      CreateCommand<OnSystemInfoChangedNotification>(message_);
 
   EXPECT_CALL(*message_helper_mock_, CommonLanguageToString(_));
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnSystemInfoChanged(_));
+  EXPECT_CALL(mock_policy_handler_, OnSystemInfoChanged(_));
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnAllowSDLFunctionalityNotificationDeviceKeyNotExist) {
-  const std::string kDeviceId = "";
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_response::allowed] = true;
+  (*message_)[strings::msg_params][am::hmi_response::allowed] = true;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAllowSDLFunctionalityNotification>(message);
+      CreateCommand<OnAllowSDLFunctionalityNotification>(message_);
 
   bool value = false;
   std::string str;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAllowSDLFunctionalityNotification(_, _))
+  EXPECT_CALL(mock_policy_handler_, OnAllowSDLFunctionalityNotification(_, _))
       .WillOnce(GetBoolValueAndString(&value, &str));
   command->Run();
   EXPECT_EQ(true, value);
-  EXPECT_EQ(kDeviceId, str);
+  EXPECT_EQ(kEmptyDeviceInternalId, str);
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnAllowSDLFunctionalityNotificationDeviceKeyExist) {
-  const std::string kDeviceId = "device_id";
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_response::allowed] = true;
-  (*message)[am::strings::msg_params]["device"]["id"] = kDeviceId;
+  (*message_)[strings::msg_params][am::hmi_response::allowed] = true;
+  (*message_)[strings::msg_params][strings::device][strings::id] = kDeviceId;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnAllowSDLFunctionalityNotification>(message);
+      CreateCommand<OnAllowSDLFunctionalityNotification>(message_);
 
   bool value;
   std::string str;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, OnAllowSDLFunctionalityNotification(_, _))
+  EXPECT_CALL(mock_policy_handler_, OnAllowSDLFunctionalityNotification(_, _))
       .WillOnce(GetBoolValueAndString(&value, &str));
   command->Run();
   EXPECT_EQ(true, value);
@@ -868,101 +752,96 @@ TEST_F(HMICommandsNotificationsTest,
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceStateChangedNotificationDeviceStateNotUnpaired) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params]["deviceState"] =
+  (*message_)[strings::msg_params]["deviceState"] =
       hmi_apis::Common_DeviceState::INVALID_ENUM;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnDeviceStateChangedNotification>(message);
+      CreateCommand<OnDeviceStateChangedNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler()).Times(0);
-  EXPECT_CALL(policy_interface_, RemoveDevice(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, RemoveDevice(_)).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceStateChangedNotificationDeviceStateUnpaired) {
-  // Random MAC adress for test. It must contain 12 symbols.
-  const std::string device_id = "AA15F2204D6B";
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params]["deviceState"] =
+  (*message_)[strings::msg_params]["deviceState"] =
       hmi_apis::Common_DeviceState::UNPAIRED;
-  (*message)[am::strings::msg_params]["deviceInternalId"] = device_id;
+  (*message_)[strings::msg_params]["deviceInternalId"] =
+      kCustomDeviceInternalId;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnDeviceStateChangedNotification>(message);
+      CreateCommand<OnDeviceStateChangedNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, RemoveDevice(_));
+  // If the "deviceInternalId" key is valid the MAC address will be hashed
+  EXPECT_CALL(mock_policy_handler_, RemoveDevice(_));
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceStateChangedNotificationDeviceStateEmptyDeviceId) {
-  const std::string empty_device_id = "";
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params]["deviceState"] =
+  (*message_)[strings::msg_params]["deviceState"] =
       hmi_apis::Common_DeviceState::UNPAIRED;
-  (*message)[am::strings::msg_params]["deviceInternalId"] = empty_device_id;
+  (*message_)[strings::msg_params]["deviceInternalId"] = kEmptyDeviceInternalId;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnDeviceStateChangedNotification>(message);
+      CreateCommand<OnDeviceStateChangedNotification>(message_);
 
-  std::string device_id = "default_id";
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, RemoveDevice(_)).WillOnce(GetArg(&device_id));
+  std::string result_device_id = "default_id";
+  EXPECT_CALL(mock_policy_handler_, RemoveDevice(_))
+      .WillOnce(GetArg(&result_device_id));
   command->Run();
-  EXPECT_EQ(empty_device_id, device_id);
+  EXPECT_EQ(kEmptyDeviceInternalId, result_device_id);
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceStateChangedNotificationDeviceStateDeviceIdFromId) {
-  const std::string empty_device_id = "";
-  const std::string id = "id_string";
   MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params]["deviceState"] =
+  (*message)[strings::msg_params]["deviceState"] =
       hmi_apis::Common_DeviceState::UNPAIRED;
-  (*message)[am::strings::msg_params]["deviceInternalId"] = empty_device_id;
-  (*message)[am::strings::msg_params]["deviceId"]["id"] = id;
+  (*message)[strings::msg_params]["deviceInternalId"] = kEmptyDeviceInternalId;
+  (*message)[strings::msg_params]["deviceId"][strings::id] = kDeviceId;
 
   utils::SharedPtr<Command> command =
       CreateCommand<OnDeviceStateChangedNotification>(message);
 
-  std::string device_id = "default_id";
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, RemoveDevice(_)).WillOnce(GetArg(&device_id));
+  std::string result_device_id = "default_id";
+  EXPECT_CALL(mock_policy_handler_, RemoveDevice(_))
+      .WillOnce(GetArg(&result_device_id));
   command->Run();
-  EXPECT_EQ(id, device_id);
+  EXPECT_EQ(kDeviceId, result_device_id);
+}
+
+MATCHER_P(ReasonCodeEqualTo, kCode, "") {
+  return kCode == arg;
+}
+
+void DummySigHandler(int) {
+  return;
 }
 
-//~policy_handler
 TEST_F(HMICommandsNotificationsTest,
        OnExitAllApplicationsNotificationReasonIgnitionOff) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_request::reason] =
+  (*message_)[strings::msg_params][am::hmi_request::reason] =
       hmi_apis::Common_ApplicationsCloseReason::IGNITION_OFF;
 
-  utils::SharedPtr<Command> command =
-      CreateCommand<OnExitAllApplicationsNotification>(message);
-#if defined(OS_POSIX)
-  am::mobile_api::AppInterfaceUnregisteredReason::eType mob_reason;
+  utils::SharedPtr<am::commands::Command> command =
+      CreateCommand<am::commands::OnExitAllApplicationsNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, SetUnregisterAllApplicationsReason(_))
-      .WillOnce(GetArg(&mob_reason));
-  EXPECT_CALL(app_mngr_, HeadUnitReset(_)).Times(0);
+  EXPECT_CALL(
+      mock_app_manager_,
+      SetUnregisterAllApplicationsReason(ReasonCodeEqualTo(
+          am::mobile_api::AppInterfaceUnregisteredReason::IGNITION_OFF)));
+  EXPECT_CALL(mock_app_manager_, HeadUnitReset(_)).Times(0);
 
-  SubscribeForSignal();
+  utils::UnsibscribeFromTermination();
   command->Run();
-  utils::WaitTerminationSignals(sig_handler);
+  utils::WaitTerminationSignals(&DummySigHandler);
 
-  EXPECT_EQ(am::mobile_api::AppInterfaceUnregisteredReason::IGNITION_OFF,
-            mob_reason);
-#endif
+  EXPECT_CALL(mock_app_manager_, SetUnregisterAllApplicationsReason(_))
+      .Times(0);
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnExitAllApplicationsNotificationReasonMasterResetAndFactoryDefaults) {
-  MessageSharedPtr message = CreateMessage();
-
   std::vector<hmi_apis::Common_ApplicationsCloseReason::eType> reason_list;
   reason_list.push_back(hmi_apis::Common_ApplicationsCloseReason::MASTER_RESET);
   reason_list.push_back(
@@ -981,88 +860,87 @@ TEST_F(HMICommandsNotificationsTest,
       it_mob_reason = mob_reason_list.begin();
 
   for (; it_reason != reason_list.end(); ++it_reason, ++it_mob_reason) {
-    (*message)[am::strings::msg_params][am::hmi_request::reason] = *it_reason;
+    (*message_)[strings::msg_params][am::hmi_request::reason] = *it_reason;
+
+    utils::SharedPtr<am::commands::Command> command =
+        CreateCommand<am::commands::OnExitAllApplicationsNotification>(
+            message_);
 
-    utils::SharedPtr<Command> command =
-        CreateCommand<OnExitAllApplicationsNotification>(message);
-#if defined(OS_POSIX)
     am::mobile_api::AppInterfaceUnregisteredReason::eType mob_reason =
         *it_mob_reason;
 
-    EXPECT_CALL(app_mngr_, SetUnregisterAllApplicationsReason(mob_reason));
-    EXPECT_CALL(app_mngr_, HeadUnitReset(mob_reason));
-
-    SubscribeForSignal();
+    EXPECT_CALL(mock_app_manager_,
+                SetUnregisterAllApplicationsReason(mob_reason));
+    EXPECT_CALL(mock_app_manager_, HeadUnitReset(mob_reason));
+    utils::UnsibscribeFromTermination();
     command->Run();
-    utils::WaitTerminationSignals(sig_handler);
-#endif
+    utils::WaitTerminationSignals(&DummySigHandler);
+    EXPECT_CALL(mock_app_manager_, SetUnregisterAllApplicationsReason(_))
+        .Times(0);
+    EXPECT_CALL(mock_app_manager_, HeadUnitReset(_)).Times(0);
   }
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnExitAllApplicationsNotificationReasonSuspend) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_request::reason] =
+  (*message_)[strings::msg_params][am::hmi_request::reason] =
       hmi_apis::Common_ApplicationsCloseReason::SUSPEND;
 
-  utils::SharedPtr<Command> command =
-      CreateCommand<OnExitAllApplicationsNotification>(message);
+  utils::SharedPtr<am::commands::Command> command =
+      CreateCommand<am::commands::OnExitAllApplicationsNotification>(message_);
 
   MessageSharedPtr ethalon_message =
       CreateMessage(smart_objects::SmartType_Map);
-  (*ethalon_message)[am::strings::params][am::strings::function_id] =
+  (*ethalon_message)[strings::params][strings::function_id] =
       hmi_apis::FunctionID::BasicCommunication_OnSDLPersistenceComplete;
-  (*ethalon_message)[am::strings::params][am::strings::message_type] =
+  (*ethalon_message)[strings::params][strings::message_type] =
       am::MessageType::kNotification;
-  (*ethalon_message)[am::strings::params][am::strings::correlation_id] =
+  (*ethalon_message)[strings::params][strings::correlation_id] =
       kCorrelationId_;
   MessageSharedPtr temp_message = CreateMessage();
 
-  EXPECT_CALL(app_mngr_, GetNextHMICorrelationID())
+  EXPECT_CALL(mock_app_manager_, GetNextHMICorrelationID())
       .WillOnce(Return(kCorrelationId_));
-  EXPECT_CALL(app_mngr_, ManageHMICommand(_))
-      .WillOnce(GetMessage(temp_message));
+  EXPECT_CALL(mock_app_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(GetMessage(temp_message), Return(true)));
   command->Run();
-  EXPECT_EQ(
-      static_cast<uint32_t>(
-          hmi_apis::FunctionID::BasicCommunication_OnSDLPersistenceComplete),
-      (*temp_message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<uint32_t>(am::MessageType::kNotification),
-      (*temp_message)[am::strings::params][am::strings::message_type].asInt());
-  EXPECT_EQ(static_cast<uint32_t>(kCorrelationId_),
-            (*temp_message)[am::strings::params][am::strings::correlation_id]
-                .asInt());
+  EXPECT_CALL(mock_app_manager_, GetNextHMICorrelationID()).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageHMICommand(_)).Times(0);
+  EXPECT_EQ((*temp_message)[strings::params][strings::function_id].asInt(),
+            hmi_apis::FunctionID::BasicCommunication_OnSDLPersistenceComplete);
+  EXPECT_EQ((*temp_message)[strings::params][strings::message_type].asInt(),
+            am::MessageType::kNotification);
+  EXPECT_EQ((*temp_message)[strings::params][strings::correlation_id].asInt(),
+            kCorrelationId_);
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnExitAllApplicationsNotificationReasonInvalidEnum) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_request::reason] =
+  (*message_)[strings::msg_params][am::hmi_request::reason] =
       hmi_apis::Common_ApplicationsCloseReason::INVALID_ENUM;
 
-  utils::SharedPtr<Command> command =
-      CreateCommand<OnExitAllApplicationsNotification>(message);
+  utils::SharedPtr<am::commands::Command> command =
+      CreateCommand<am::commands::OnExitAllApplicationsNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, SetUnregisterAllApplicationsReason(_)).Times(0);
-  EXPECT_CALL(app_mngr_, HeadUnitReset(_)).Times(0);
-  EXPECT_CALL(app_mngr_, GetNextHMICorrelationID()).Times(0);
-  EXPECT_CALL(app_mngr_, ManageHMICommand(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, SetUnregisterAllApplicationsReason(_))
+      .Times(0);
+  EXPECT_CALL(mock_app_manager_, HeadUnitReset(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, GetNextHMICorrelationID()).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageHMICommand(_)).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnExitApplicationNotificationManageMobileCommand) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>();
-  (*notification)[am::strings::params][am::strings::function_id] =
-      static_cast<int32_t>(
-          mobile_apis::FunctionID::OnAppInterfaceUnregisteredID);
-  (*notification)[am::strings::params][am::strings::message_type] =
-      static_cast<int32_t>(am::MessageType::kNotification);
-  (*notification)[am::strings::params][am::strings::connection_key] = kAppId_;
+  (*notification)[strings::params][strings::function_id] =
+
+      mobile_apis::FunctionID::OnAppInterfaceUnregisteredID;
+  (*notification)[strings::params][strings::message_type] =
+      am::MessageType::kNotification;
+  (*notification)[strings::params][strings::connection_key] = kAppId;
 
   std::vector<hmi_apis::Common_ApplicationExitReason::eType> reason_list;
   reason_list.push_back(hmi_apis::Common_ApplicationExitReason::
@@ -1083,76 +961,106 @@ TEST_F(HMICommandsNotificationsTest,
       it_reason = reason_list.begin();
 
   for (; it_reason != reason_list.end(); ++it_reason, ++it_mobile_reason) {
-    (*message)[am::strings::msg_params][am::strings::reason] = *it_reason;
+    (*message_)[strings::msg_params][strings::reason] = *it_reason;
     utils::SharedPtr<Command> command =
-        CreateCommand<OnExitApplicationNotification>(message);
+        CreateCommand<OnExitApplicationNotification>(message_);
 
-    (*notification)[am::strings::msg_params][am::strings::reason] =
+    (*notification)[strings::msg_params][strings::reason] =
         static_cast<int32_t>(*it_mobile_reason);
 
-    EXPECT_CALL(app_mngr_, application(kAppId_)).WillRepeatedly(Return(app_));
+    EXPECT_CALL(mock_app_manager_, application(kAppId))
+        .WillRepeatedly(Return(mock_app_));
     EXPECT_CALL(*message_helper_mock_,
                 GetOnAppInterfaceUnregisteredNotificationToMobile(
-                    kAppId_, *it_mobile_reason)).WillOnce(Return(notification));
-    EXPECT_CALL(app_mngr_,
+                    kAppId, *it_mobile_reason)).WillOnce(Return(notification));
+    EXPECT_CALL(mock_app_manager_,
                 ManageMobileCommand(notification, Command::ORIGIN_SDL));
-    EXPECT_CALL(app_mngr_,
+    EXPECT_CALL(mock_app_manager_,
                 UnregisterApplication(
-                    kAppId_, mobile_apis::Result::SUCCESS, false, false));
+                    kAppId, mobile_apis::Result::SUCCESS, false, false));
     command->Run();
   }
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnExitApplicationNotificationUnhandledReason) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
 
-  (*message)[am::strings::msg_params][am::strings::reason] =
+  (*message_)[strings::msg_params][strings::reason] =
       hmi_apis::Common_ApplicationExitReason::INVALID_ENUM;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnExitApplicationNotification>(message);
+      CreateCommand<OnExitApplicationNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(app_mngr_, UnregisterApplication(_, _, _, _)).Times(0);
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillOnce(Return(app_));
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, UnregisterApplication(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillOnce(Return(mock_app_));
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest, OnExitApplicationNotificationInvalidApp) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
 
   utils::SharedPtr<Command> command =
-      CreateCommand<OnExitApplicationNotification>(message);
+      CreateCommand<OnExitApplicationNotification>(message_);
 
   am::ApplicationSharedPtr invalid_app;
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(app_mngr_, UnregisterApplication(_, _, _, _)).Times(0);
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillOnce(Return(invalid_app));
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, UnregisterApplication(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillOnce(Return(invalid_app));
+  command->Run();
+}
+
+TEST_F(HMICommandsNotificationsTest, Run_InvalidApp_UNSUCCESS) {
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params][strings::reason] =
+      hmi_apis::Common_ApplicationExitReason::DRIVER_DISTRACTION_VIOLATION;
+  utils::SharedPtr<Command> command =
+      CreateCommand<OnExitApplicationNotification>(message_);
+
+  MockAppPtr valid_app = CreateMockApp();
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillOnce(Return(valid_app))
+      .WillOnce(Return(MockAppPtr()));
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, UnregisterApplication(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
+
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
-       DISABLED_OnExitApplicationNotificationDriverDistractionValidApp) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
-  (*message)[am::strings::msg_params][am::strings::reason] =
+       OnExitApplicationNotificationDriverDistractionValidApp) {
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params][strings::reason] =
       hmi_apis::Common_ApplicationExitReason::DRIVER_DISTRACTION_VIOLATION;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnExitApplicationNotification>(message);
+      CreateCommand<OnExitApplicationNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillRepeatedly(Return(app_));
+  smart_objects::SmartObjectSPtr notification =
+      utils::MakeShared<smart_objects::SmartObject>();
+  (*notification)[strings::params][strings::function_id] =
 
-  EXPECT_CALL(app_mngr_, state_controller())
+      mobile_apis::FunctionID::OnAppInterfaceUnregisteredID;
+  (*notification)[strings::params][strings::message_type] =
+      am::MessageType::kNotification;
+  (*notification)[strings::params][strings::connection_key] = kAppId;
+  (*notification)[strings::msg_params][strings::reason] =
+      mobile_apis::AppInterfaceUnregisteredReason::DRIVER_DISTRACTION_VIOLATION;
+
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillRepeatedly(Return(mock_app_));
+
+  EXPECT_CALL(mock_app_manager_, state_controller())
       .WillOnce(ReturnRef(mock_state_controller_));
   EXPECT_CALL(mock_state_controller_,
-              SetRegularState(app_,
+              SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_),
                               mobile_apis::HMILevel::HMI_NONE,
                               mobile_apis::AudioStreamingState::NOT_AUDIBLE,
                               false));
@@ -1160,21 +1068,36 @@ TEST_F(HMICommandsNotificationsTest,
 }
 
 TEST_F(HMICommandsNotificationsTest,
-       OnExitApplicationNotificationrUserExitValidApp) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
-  (*message)[am::strings::msg_params][am::strings::reason] =
+       OnExitApplicationNotificationDriverDistractionInvalidApp) {
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+
+  utils::SharedPtr<Command> command =
+      CreateCommand<OnExitApplicationNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+
+  command->Run();
+}
+
+TEST_F(HMICommandsNotificationsTest,
+       OnExitApplicationNotificationUserExitValidApp) {
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
+  (*message_)[strings::msg_params][strings::reason] =
       hmi_apis::Common_ApplicationExitReason::USER_EXIT;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnExitApplicationNotification>(message);
+      CreateCommand<OnExitApplicationNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillRepeatedly(Return(app_));
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(app_mngr_, UnregisterApplication(_, _, _, _)).Times(0);
-  EXPECT_CALL(app_mngr_, state_controller())
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillRepeatedly(Return(mock_app_));
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, UnregisterApplication(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller())
       .WillOnce(ReturnRef(mock_state_controller_));
   EXPECT_CALL(mock_state_controller_,
-              SetRegularState(app_,
+              SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_),
                               mobile_apis::HMILevel::HMI_NONE,
                               mobile_apis::AudioStreamingState::NOT_AUDIBLE,
                               false));
@@ -1183,23 +1106,28 @@ TEST_F(HMICommandsNotificationsTest,
 
 TEST_F(HMICommandsNotificationsTest,
        OnVRCommandNotificationSwitchedAndValidApp) {
-  const uint32_t cmd_id = 12u;
+  const uint32_t cmnd_id = 12u;
   const uint32_t max_cmd_id = 10u;
 
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = cmd_id;
+  (*message_)[strings::msg_params][strings::cmd_id] = cmnd_id;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
+      CreateCommand<OnVRCommandNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, application(cmnd_id - max_cmd_id))
+      .WillOnce(Return(mock_app_));
 
-  EXPECT_CALL(app_mngr_, application(_)).WillRepeatedly(Return(app_));
-  EXPECT_CALL(app_mngr_, state_controller())
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(max_cmd_id));
+
+  EXPECT_CALL(mock_app_manager_, state_controller())
       .WillOnce(ReturnRef(mock_state_controller_));
   EXPECT_CALL(mock_state_controller_,
-              SetRegularState(_, mobile_apis::HMILevel::HMI_FULL, true));
+              SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_),
+                              mobile_apis::HMILevel::HMI_FULL,
+                              true));
 
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(max_cmd_id));
   command->Run();
 }
 
@@ -1208,17 +1136,18 @@ TEST_F(HMICommandsNotificationsTest,
   const uint32_t kCmdId = 12u;
   const uint32_t kMaxCmdId = 10u;
 
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
+  (*message_)[strings::msg_params][strings::cmd_id] = kCmdId;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
+      CreateCommand<OnVRCommandNotification>(message_);
 
   am::ApplicationSharedPtr invalid_app;
-  EXPECT_CALL(app_mngr_, application(_)).WillRepeatedly(Return(invalid_app));
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(kMaxCmdId));
+  EXPECT_CALL(mock_app_manager_, application(_))
+      .WillRepeatedly(Return(invalid_app));
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(kMaxCmdId));
   command->Run();
 }
 
@@ -1227,15 +1156,15 @@ TEST_F(HMICommandsNotificationsTest,
   const uint32_t kCmdId = 11u;
   const uint32_t kMaxCmdId = 10u;
 
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
+  (*message_)[strings::msg_params][strings::cmd_id] = kCmdId;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
+      CreateCommand<OnVRCommandNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(kMaxCmdId));
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(kMaxCmdId));
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
   command->Run();
 }
 
@@ -1244,18 +1173,20 @@ TEST_F(HMICommandsNotificationsTest,
   const uint32_t kCmdId = 8u;
   const uint32_t kMaxCmdId = 10u;
 
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
+  (*message_)[strings::msg_params][strings::cmd_id] = kCmdId;
+  (*message_)[strings::msg_params][strings::grammar_id] = 0;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
+      CreateCommand<OnVRCommandNotification>(message_);
 
-  am::ApplicationSharedPtr invalid_app;
-  EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(invalid_app));
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(kMaxCmdId));
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
-  EXPECT_CALL(app_mngr_, event_dispatcher()).Times(0);
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(kMaxCmdId));
+
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
   command->Run();
 }
 
@@ -1265,21 +1196,24 @@ TEST_F(HMICommandsNotificationsTest,
   const uint32_t kMaxCmdId = 10u;
   const uint32_t kIsPerformInteractionActive = 1u;
   int32_t event_id = hmi_apis::FunctionID::INVALID_ENUM;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
-  utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
 
-  EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(app_));
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(kMaxCmdId));
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
-  EXPECT_CALL(*app_ptr_, is_perform_interaction_active())
+  (*message_)[strings::msg_params][strings::cmd_id] = kCmdId;
+  utils::SharedPtr<Command> command =
+      CreateCommand<OnVRCommandNotification>(message_);
+
+  application_set_.insert(mock_app_);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(kMaxCmdId));
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
+  EXPECT_CALL(*mock_app_, is_perform_interaction_active())
       .WillOnce(Return(kIsPerformInteractionActive));
-  EXPECT_CALL(app_mngr_, event_dispatcher());
+  EXPECT_CALL(mock_app_manager_, event_dispatcher());
   EXPECT_CALL(mock_event_dispatcher_, raise_event(_))
       .WillOnce(GetEventId(&event_id));
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
   command->Run();
   EXPECT_EQ(hmi_apis::FunctionID::VR_OnCommand, event_id);
 }
@@ -1289,179 +1223,177 @@ TEST_F(HMICommandsNotificationsTest,
   const uint32_t kCmdId = 8u;
   const uint32_t kMaxCmdId = 10u;
   const uint32_t kIsPerformInteractionActive = 0u;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::cmd_id] = kCmdId;
-  (*message)[am::strings::msg_params][am::strings::function_id] =
+
+  (*message_)[strings::msg_params][strings::cmd_id] = kCmdId;
+  (*message_)[strings::msg_params][strings::function_id] =
       mobile_apis::FunctionID::eType::OnCommandID;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRCommandNotification>(message);
-
-  EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(app_));
-  EXPECT_CALL(app_mngr_settings_, max_cmd_id()).WillOnce(ReturnRef(kMaxCmdId));
-  EXPECT_CALL(app_mngr_, get_settings())
-      .WillOnce(ReturnRef(app_mngr_settings_));
-  EXPECT_CALL(*app_ptr_, is_perform_interaction_active())
+      CreateCommand<OnVRCommandNotification>(message_);
+
+  application_set_.insert(mock_app_);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_settings_, max_cmd_id())
+      .WillOnce(ReturnRef(kMaxCmdId));
+  EXPECT_CALL(mock_app_manager_, get_settings())
+      .WillOnce(ReturnRef(mock_app_manager_settings_));
+  EXPECT_CALL(*mock_app_, is_perform_interaction_active())
       .WillOnce(Return(kIsPerformInteractionActive));
 
-  EXPECT_CALL(app_mngr_, event_dispatcher()).Times(0);
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_, event_dispatcher()).Times(0);
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::eType::OnCommandID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(mobile_apis::TriggerSource::TS_VR),
-      (*message)[am::strings::msg_params][am::strings::trigger_source].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(static_cast<int32_t>(mobile_apis::TriggerSource::TS_VR),
+            (*message_)[strings::msg_params][strings::trigger_source].asInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnVRLanguageChangeNotificationEmptyData) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRLanguageChangeNotification>(message);
+      CreateCommand<OnVRLanguageChangeNotification>(message_);
 
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
-  EXPECT_CALL(*app_ptr_, language()).Times(0);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(*mock_app_, app_id()).Times(0);
+  EXPECT_CALL(*mock_app_, language()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnVRLanguageChangeNotificationAppLangEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRLanguageChangeNotification>(message);
+      CreateCommand<OnVRLanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  application_set_.insert(mock_app_);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillOnce(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, language()).WillRepeatedly(ReturnRef(kLang));
+  ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+  ON_CALL(*mock_app_, language()).WillByDefault(ReturnRef(kLang));
 
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(hmi_apis::Common_Language::EN_AU),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnVRLanguageChangeNotificationAppLangNotEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] =
+
+  (*message_)[strings::msg_params][strings::language] =
       mobile_apis::Language::EN_US;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnVRLanguageChangeNotification>(message);
+      CreateCommand<OnVRLanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
+  application_set_.insert(mock_app_);
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>();
-  (*notification)[am::strings::params][am::strings::function_id] =
-      static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID);
-  (*notification)[am::strings::params][am::strings::message_type] =
-      static_cast<int32_t>(am::MessageType::kNotification);
-  (*notification)[am::strings::params][am::strings::connection_key] = kAppId_;
-  (*notification)[am::strings::msg_params][am::strings::reason] =
-      static_cast<int32_t>(
-          mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE);
-
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  (*notification)[strings::params][strings::function_id] =
+      mobile_apis::FunctionID::OnLanguageChangeID;
+  (*notification)[strings::params][strings::message_type] =
+      am::MessageType::kNotification;
+  (*notification)[strings::params][strings::connection_key] = kAppId;
+  (*notification)[strings::msg_params][strings::reason] =
+      mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE;
+
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillRepeatedly(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, language()).WillRepeatedly(ReturnRef(kLang));
-  EXPECT_CALL(app_mngr_, state_controller())
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId));
+  EXPECT_CALL(*mock_app_, language()).WillRepeatedly(ReturnRef(kLang));
+  EXPECT_CALL(mock_app_manager_, state_controller())
       .WillOnce(ReturnRef(mock_state_controller_));
   EXPECT_CALL(mock_state_controller_,
-              SetRegularState(app_, mobile_apis::HMILevel::HMI_NONE, false));
-  EXPECT_CALL(*message_helper_mock_,
-              GetOnAppInterfaceUnregisteredNotificationToMobile(
-                  kAppId_,
-                  mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
+              SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_),
+                              mobile_apis::HMILevel::HMI_NONE,
+                              false));
+  EXPECT_CALL(
+      *message_helper_mock_,
+      GetOnAppInterfaceUnregisteredNotificationToMobile(
+          kAppId, mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
       .WillOnce(Return(notification));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(notification, Command::ORIGIN_SDL));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               UnregisterApplication(
-                  kAppId_, mobile_apis::Result::SUCCESS, false, false));
+                  kAppId, mobile_apis::Result::SUCCESS, false, false));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(hmi_apis::Common_Language::EN_AU),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnStartDeviceDiscoveryRun) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnStartDeviceDiscovery>(message);
-  EXPECT_CALL(app_mngr_, StartDevicesDiscovery());
+      CreateCommand<OnStartDeviceDiscovery>(message_);
+  EXPECT_CALL(mock_app_manager_, StartDevicesDiscovery());
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceChosenNotificationDeviceInfoExists) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::device_info]
-            [am::strings::id] = "2014";
+  (*message_)[strings::msg_params][strings::device_info][strings::id] = "2014";
   utils::SharedPtr<Command> command =
-      CreateCommand<OnDeviceChosenNotification>(message);
-  EXPECT_CALL(app_mngr_,
-              ConnectToDevice(
-                  (*message)[am::strings::msg_params][am::strings::device_info]
-                            [am::strings::id].asString()));
+      CreateCommand<OnDeviceChosenNotification>(message_);
+  EXPECT_CALL(
+      mock_app_manager_,
+      ConnectToDevice(
+          (*message_)[strings::msg_params][strings::device_info][strings::id]
+              .asString()));
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnDeviceChosenNotificationDeviceInfoNotExists) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnDeviceChosenNotification>(message);
-  EXPECT_CALL(app_mngr_, ConnectToDevice(_)).Times(0);
+      CreateCommand<OnDeviceChosenNotification>(message_);
+  EXPECT_CALL(mock_app_manager_, ConnectToDevice(_)).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemContextNotificationValidActiveApplication) {
-  MessageSharedPtr message = CreateMessage();
   std::vector<am::mobile_api::SystemContext::eType> system_context_list;
   system_context_list.push_back(
       am::mobile_api::SystemContext::SYSCTXT_VRSESSION);
@@ -1472,48 +1404,49 @@ TEST_F(HMICommandsNotificationsTest,
   std::vector<am::mobile_api::SystemContext::eType>::iterator it =
       system_context_list.begin();
   for (; it != system_context_list.end(); ++it) {
-    (*message)[am::strings::msg_params][am::hmi_notification::system_context] =
+    (*message_)[strings::msg_params][am::hmi_notification::system_context] =
         *it;
     utils::SharedPtr<Command> command =
-        CreateCommand<OnSystemContextNotification>(message);
-    EXPECT_CALL(app_mngr_, active_application()).WillOnce(Return(app_));
-    EXPECT_CALL(app_mngr_, state_controller())
+        CreateCommand<OnSystemContextNotification>(message_);
+    EXPECT_CALL(mock_app_manager_, active_application())
+        .WillOnce(Return(mock_app_));
+    EXPECT_CALL(mock_app_manager_, state_controller())
         .WillOnce(ReturnRef(mock_state_controller_));
-    EXPECT_CALL(mock_state_controller_, SetRegularState(app_, *it));
+    EXPECT_CALL(
+        mock_state_controller_,
+        SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_), *it));
     command->Run();
   }
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemContextNotificationInvalidActiveApplication) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::system_context] =
+  (*message_)[strings::msg_params][am::hmi_notification::system_context] =
       am::mobile_api::SystemContext::SYSCTXT_VRSESSION;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemContextNotification>(message);
+      CreateCommand<OnSystemContextNotification>(message_);
   ApplicationSharedPtr invalid_app;
-  EXPECT_CALL(app_mngr_, active_application()).WillOnce(Return(invalid_app));
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
+  EXPECT_CALL(mock_app_manager_, active_application())
+      .WillOnce(Return(invalid_app));
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemContextNotificationInvalidSystemContext) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::system_context] =
+  (*message_)[strings::msg_params][am::hmi_notification::system_context] =
       am::mobile_api::SystemContext::INVALID_ENUM;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemContextNotification>(message);
-  EXPECT_CALL(app_mngr_, active_application()).Times(0);
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
+      CreateCommand<OnSystemContextNotification>(message_);
+  EXPECT_CALL(mock_app_manager_, active_application()).Times(0);
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemContextNotificationValidApplication) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
   std::vector<am::mobile_api::SystemContext::eType> system_context_list;
   system_context_list.push_back(am::mobile_api::SystemContext::SYSCTXT_ALERT);
   system_context_list.push_back(am::mobile_api::SystemContext::SYSCTXT_MAIN);
@@ -1521,402 +1454,489 @@ TEST_F(HMICommandsNotificationsTest,
   std::vector<am::mobile_api::SystemContext::eType>::iterator it =
       system_context_list.begin();
   for (; it != system_context_list.end(); ++it) {
-    (*message)[am::strings::msg_params][am::hmi_notification::system_context] =
+    (*message_)[strings::msg_params][am::hmi_notification::system_context] =
         *it;
     utils::SharedPtr<Command> command =
-        CreateCommand<OnSystemContextNotification>(message);
-    EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(app_));
-    EXPECT_CALL(app_mngr_, state_controller())
+        CreateCommand<OnSystemContextNotification>(message_);
+    EXPECT_CALL(mock_app_manager_, application(_)).WillOnce(Return(mock_app_));
+    EXPECT_CALL(mock_app_manager_, state_controller())
         .WillOnce(ReturnRef(mock_state_controller_));
-    EXPECT_CALL(mock_state_controller_, SetRegularState(app_, *it));
+    EXPECT_CALL(
+        mock_state_controller_,
+        SetRegularState(static_cast<am::ApplicationSharedPtr>(mock_app_), *it));
     command->Run();
   }
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemContextNotificationAppIdDoesntExists) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::system_context] =
+  (*message_)[strings::msg_params][am::hmi_notification::system_context] =
       am::mobile_api::SystemContext::SYSCTXT_ALERT;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemContextNotification>(message);
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
+      CreateCommand<OnSystemContextNotification>(message_);
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, state_controller()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemRequestNotificationAppIdExistsAndValidApp) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemRequestNotification>(message);
-
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillOnce(Return(app_));
-  ON_CALL(app_mngr_, connection_handler())
-      .WillByDefault(ReturnRef(mock_connection_handler_));
-  ON_CALL(mock_connection_handler_, get_session_observer())
-      .WillByDefault(ReturnRef(mock_session_observer_));
-  const int32_t device_id = 1;
-  ON_CALL(mock_session_observer_, GetDataOnDeviceID(_, NULL, NULL, _, NULL))
-      .WillByDefault(Return(device_id));
-
-  EXPECT_CALL(policy_interface_, GetUserConsentForDevice(_))
-      .WillOnce(Return(policy::kDeviceAllowed));
+      CreateCommand<OnSystemRequestNotification>(message_);
 
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillOnce(Return(mock_app_));
+  ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(mobile_apis::FunctionID::eType::OnSystemRequestID),
-      (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+      (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemRequestNotificationAppIdExistsAndInvalidApp) {
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::app_id] = kAppId_;
+  (*message_)[strings::msg_params][strings::app_id] = kAppId;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemRequestNotification>(message);
+      CreateCommand<OnSystemRequestNotification>(message_);
   ApplicationSharedPtr invalid_app;
-  EXPECT_CALL(app_mngr_, application(kAppId_)).WillOnce(Return(invalid_app));
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, application(kAppId))
+      .WillOnce(Return(invalid_app));
+  EXPECT_CALL(*mock_app_, app_id()).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
   command->Run();
   EXPECT_EQ(
       static_cast<int32_t>(mobile_apis::FunctionID::eType::OnSystemRequestID),
-      (*message)[am::strings::params][am::strings::function_id].asInt());
+      (*message_)[strings::params][strings::function_id].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemRequestNotificationAppIdDoesntExistsAndValidApp) {
-  MessageSharedPtr message = CreateMessage();
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemRequestNotification>(message);
-  ON_CALL(app_mngr_, GetPolicyHandler())
-      .WillByDefault(ReturnRef(policy_interface_));
-  EXPECT_CALL(policy_interface_, GetAppIdForSending())
-      .WillOnce(Return(kAppId_));
-  EXPECT_CALL(app_mngr_, application(_)).WillOnce(Return(app_));
-  ON_CALL(app_mngr_, connection_handler())
-      .WillByDefault(ReturnRef(mock_connection_handler_));
-  ON_CALL(mock_connection_handler_, get_session_observer())
-      .WillByDefault(ReturnRef(mock_session_observer_));
-  const int32_t device_id = 1;
-  ON_CALL(mock_session_observer_, GetDataOnDeviceID(_, NULL, NULL, _, NULL))
-      .WillByDefault(Return(device_id));
-
-  EXPECT_CALL(policy_interface_, GetUserConsentForDevice(_))
-      .WillOnce(Return(policy::kDeviceAllowed));
-  EXPECT_CALL(app_mngr_,
+      CreateCommand<OnSystemRequestNotification>(message_);
+  EXPECT_CALL(mock_policy_handler_, GetAppIdForSending())
+      .WillOnce(Return(kAppId));
+  EXPECT_CALL(mock_app_manager_, application(_)).WillOnce(Return(mock_app_));
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(mobile_apis::FunctionID::eType::OnSystemRequestID),
-      (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+      (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnSystemRequestNotificationAppIdDoesntExistsAndNullAppId) {
   const uint32_t kNullApppId = 0u;
-  MessageSharedPtr message = CreateMessage();
+
   utils::SharedPtr<Command> command =
-      CreateCommand<OnSystemRequestNotification>(message);
-  EXPECT_CALL(app_mngr_, GetPolicyHandler());
-  EXPECT_CALL(policy_interface_, GetAppIdForSending())
+      CreateCommand<OnSystemRequestNotification>(message_);
+  EXPECT_CALL(mock_policy_handler_, GetAppIdForSending())
       .WillOnce(Return(kNullApppId));
-  EXPECT_CALL(app_mngr_, application(_)).Times(0);
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(mock_app_manager_, application(_)).Times(0);
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest, OnTTSLanguageChangeNotificationEmptyData) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnTTSLanguageChangeNotification>(message);
+      CreateCommand<OnTTSLanguageChangeNotification>(message_);
 
   EXPECT_CALL(mock_hmi_capabilities_, set_active_tts_language(_));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
-  EXPECT_CALL(*app_ptr_, language()).Times(0);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(*mock_app_, app_id()).Times(0);
+  EXPECT_CALL(*mock_app_, language()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnTTSLanguageChangeNotificationAppLangEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnTTSLanguageChangeNotification>(message);
+      CreateCommand<OnTTSLanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  application_set_.insert(mock_app_);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_tts_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillOnce(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, language()).WillRepeatedly(ReturnRef(kLang));
+  ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+  ON_CALL(*mock_app_, language()).WillByDefault(ReturnRef(kLang));
 
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(hmi_apis::Common_Language::EN_AU),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnTTSLanguageChangeNotificationAppLangNotEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] =
+
+  (*message_)[strings::msg_params][strings::language] =
       mobile_apis::Language::EN_US;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnTTSLanguageChangeNotification>(message);
+      CreateCommand<OnTTSLanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
+  application_set_.insert(mock_app_);
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>();
-  (*notification)[am::strings::params][am::strings::function_id] =
-      static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID);
-  (*notification)[am::strings::params][am::strings::message_type] =
-      static_cast<int32_t>(am::MessageType::kNotification);
-  (*notification)[am::strings::params][am::strings::connection_key] = kAppId_;
-  (*notification)[am::strings::msg_params][am::strings::reason] =
-      static_cast<int32_t>(
-          mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE);
-
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  (*notification)[strings::params][strings::function_id] =
+      mobile_apis::FunctionID::OnLanguageChangeID;
+  (*notification)[strings::params][strings::message_type] =
+      am::MessageType::kNotification;
+  (*notification)[strings::params][strings::connection_key] = kAppId;
+  (*notification)[strings::msg_params][strings::reason] =
+      mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE;
+
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_vr_language(_));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_tts_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillRepeatedly(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, language()).WillRepeatedly(ReturnRef(kLang));
-  EXPECT_CALL(*message_helper_mock_,
-              GetOnAppInterfaceUnregisteredNotificationToMobile(
-                  kAppId_,
-                  mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId));
+  EXPECT_CALL(*mock_app_, language()).WillRepeatedly(ReturnRef(kLang));
+  EXPECT_CALL(
+      *message_helper_mock_,
+      GetOnAppInterfaceUnregisteredNotificationToMobile(
+          kAppId, mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
       .WillOnce(Return(notification));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(notification, Command::ORIGIN_SDL));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               UnregisterApplication(
-                  kAppId_, mobile_apis::Result::SUCCESS, false, false));
+                  kAppId, mobile_apis::Result::SUCCESS, false, false));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(hmi_apis::Common_Language::EN_AU),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest, OnUILanguageChangeNotificationEmptyData) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnUILanguageChangeNotification>(message);
+      CreateCommand<OnUILanguageChangeNotification>(message_);
 
   EXPECT_CALL(mock_hmi_capabilities_, set_active_ui_language(_));
   EXPECT_CALL(mock_hmi_capabilities_, active_vr_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
-  EXPECT_CALL(*app_ptr_, ui_language()).Times(0);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_, ManageMobileCommand(_, _)).Times(0);
+  EXPECT_CALL(*mock_app_, app_id()).Times(0);
+  EXPECT_CALL(*mock_app_, ui_language()).Times(0);
   command->Run();
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnUILanguageChangeNotificationAppLangEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] = kLang;
+  (*message_)[strings::msg_params][strings::language] = kLang;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnUILanguageChangeNotification>(message);
+      CreateCommand<OnUILanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  application_set_.insert(mock_app_);
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_vr_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_ui_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillOnce(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, ui_language()).WillRepeatedly(ReturnRef(kLang));
+  ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+  ON_CALL(*mock_app_, ui_language()).WillByDefault(ReturnRef(kLang));
 
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(kLang),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
 TEST_F(HMICommandsNotificationsTest,
        OnUILanguageChangeNotificationAppLangNotEqualMessageLang) {
   const mobile_apis::Language::eType& kLang = mobile_apis::Language::EN_GB;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::strings::language] =
+
+  (*message_)[strings::msg_params][strings::language] =
       mobile_apis::Language::EN_US;
   utils::SharedPtr<Command> command =
-      CreateCommand<OnUILanguageChangeNotification>(message);
+      CreateCommand<OnUILanguageChangeNotification>(message_);
 
-  application_set_.insert(app_);
+  application_set_.insert(mock_app_);
   smart_objects::SmartObjectSPtr notification =
       utils::MakeShared<smart_objects::SmartObject>();
-  (*notification)[am::strings::params][am::strings::function_id] =
-      static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID);
-  (*notification)[am::strings::params][am::strings::message_type] =
-      static_cast<int32_t>(am::MessageType::kNotification);
-  (*notification)[am::strings::params][am::strings::connection_key] = kAppId_;
-  (*notification)[am::strings::msg_params][am::strings::reason] =
-      static_cast<int32_t>(
-          mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE);
-
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  (*notification)[strings::params][strings::function_id] =
+      mobile_apis::FunctionID::OnLanguageChangeID;
+  (*notification)[strings::params][strings::message_type] =
+      am::MessageType::kNotification;
+  (*notification)[strings::params][strings::connection_key] = kAppId;
+  (*notification)[strings::msg_params][strings::reason] =
+      mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE;
+
+  EXPECT_CALL(mock_app_manager_, applications())
+      .WillOnce(Return(applications_));
   EXPECT_CALL(mock_hmi_capabilities_, active_vr_language())
       .WillOnce(Return(hmi_apis::Common_Language::EN_AU));
   EXPECT_CALL(mock_hmi_capabilities_, set_active_ui_language(_));
-  EXPECT_CALL(app_mngr_, hmi_capabilities())
+  EXPECT_CALL(mock_app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities_));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL));
-  EXPECT_CALL(*app_ptr_, app_id()).WillRepeatedly(Return(kAppId_));
-  EXPECT_CALL(*app_ptr_, ui_language()).WillRepeatedly(ReturnRef(kLang));
-  EXPECT_CALL(*message_helper_mock_,
-              GetOnAppInterfaceUnregisteredNotificationToMobile(
-                  kAppId_,
-                  mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId));
+  EXPECT_CALL(*mock_app_, ui_language()).WillRepeatedly(ReturnRef(kLang));
+  EXPECT_CALL(
+      *message_helper_mock_,
+      GetOnAppInterfaceUnregisteredNotificationToMobile(
+          kAppId, mobile_apis::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE))
       .WillOnce(Return(notification));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               ManageMobileCommand(notification, Command::ORIGIN_SDL));
-  EXPECT_CALL(app_mngr_,
+  EXPECT_CALL(mock_app_manager_,
               UnregisterApplication(
-                  kAppId_, mobile_apis::Result::SUCCESS, false, false));
+                  kAppId, mobile_apis::Result::SUCCESS, false, false));
   command->Run();
   EXPECT_EQ(static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID),
-            (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
+            (*message_)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId,
+            (*message_)[strings::params][strings::connection_key].asUInt());
   EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
+            (*message_)[strings::params][strings::message_type].asInt());
   EXPECT_EQ(
       static_cast<int32_t>(mobile_apis::Language::EN_US),
-      (*message)[am::strings::msg_params][am::strings::hmi_display_language]
-          .asInt());
+      (*message_)[strings::msg_params][strings::hmi_display_language].asInt());
 }
 
-TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationEmptyData) {
-  const hmi_apis::Common_DriverDistractionState::eType state =
-      hmi_apis::Common_DriverDistractionState::DD_ON;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::state] = state;
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_DeviceKeyNotExist_IgnoreNotification) {
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnDriverDistractionNotification>(message);
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
 
-  EXPECT_CALL(app_mngr_, set_driver_distraction(state));
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
+  command->Run();
+}
 
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_MandatoryParamsMissing_IgnoreNotification) {
+  (*message_)[strings::msg_params][strings::device] = SmartObject();
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
   command->Run();
 }
 
-TEST_F(HMICommandsNotificationsTest,
-       OnDriverDistractionNotificationInvalidApp) {
-  const hmi_apis::Common_DriverDistractionState::eType state =
-      hmi_apis::Common_DriverDistractionState::DD_ON;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::hmi_notification::state] = state;
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_MandatoryIntegerParamsMissing_IgnoreNotification) {
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::ENABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::id] = kDeviceId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnDriverDistractionNotification>(message);
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
 
-  ApplicationSharedPtr invalid_app;
-  application_set_.insert(invalid_app);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
+  command->Run();
+}
+
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_MandatoryStringParamsMissing_IgnoreNotification) {
+  const hmi_apis::Common_TransportType::eType transport_type =
+      hmi_apis::Common_TransportType::USB_AOA;
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::ENABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type;
+  device_so[strings::usb_transport_status] = usb_transport_status;
 
-  EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0);
-  EXPECT_CALL(*app_ptr_, app_id()).Times(0);
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
   command->Run();
 }
 
-TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationValidApp) {
-  const hmi_apis::Common_DriverDistractionState::eType state =
-      hmi_apis::Common_DriverDistractionState::DD_ON;
-  MessageSharedPtr message = CreateMessage();
-  (*message)[am::strings::msg_params][am::mobile_notification::state] = state;
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_StringParamsEmpty_IgnoreNotification) {
+  const hmi_apis::Common_TransportType::eType transport_type =
+      hmi_apis::Common_TransportType::USB_AOA;
+  const std::string connection_type = "USB_AOA";
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::ENABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type;
+  device_so[strings::id] = kEmptyDeviceInternalId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
   utils::SharedPtr<Command> command =
-      CreateCommand<hmi::OnDriverDistractionNotification>(message);
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
 
-  application_set_.insert(app_);
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(_)).Times(0);
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
+  command->Run();
+}
 
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
-  EXPECT_CALL(app_mngr_,
-              ManageMobileCommand(_, Command::CommandOrigin::ORIGIN_SDL))
-      .WillOnce(GetMessage(message));
-  EXPECT_CALL(*app_ptr_, app_id()).WillRepeatedly(Return(kAppId_));
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_InvalidTransportType_IgnoreNotification) {
+  const hmi_apis::Common_TransportType::eType transport_type_value =
+      hmi_apis::Common_TransportType::INVALID_ENUM;
+  const std::string connection_type;
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::ENABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type_value;
+  device_so[strings::id] = kDeviceId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(transport_type_value))
+      .WillOnce(Return(connection_type));
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
+  command->Run();
+}
+
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_USBTransportStatusInvalid_IgnoreNotification) {
+  const hmi_apis::Common_TransportType::eType transport_type_value =
+      hmi_apis::Common_TransportType::USB_AOA;
+  const std::string connection_type = "USB_AOA";
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::INVALID_ENUM;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type_value;
+  device_so[strings::id] = kDeviceId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(transport_type_value))
+      .WillOnce(Return(connection_type));
+  EXPECT_CALL(mock_policy_handler_, OnDeviceConnectionStatus(_, _)).Times(0);
+  command->Run();
+}
+
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_NotificationValidUSBTransportEnable_SendNotificationToPolicy) {
+  const hmi_apis::Common_TransportType::eType transport_type_value =
+      hmi_apis::Common_TransportType::USB_AOA;
+  const std::string connection_type = "USB_AOA";
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::ENABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type_value;
+  device_so[strings::id] = kDeviceId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(transport_type_value))
+      .WillOnce(Return(connection_type));
+  EXPECT_CALL(mock_policy_handler_,
+              OnDeviceConnectionStatus(kDeviceId, usb_transport_status));
+  command->Run();
+}
+
+TEST_F(
+    HMICommandsNotificationsTest,
+    OnDeviceConnectionStatusNotification_NotificationValidUSBTransportDisable_SendNotificationToPolicy) {
+  const hmi_apis::Common_TransportType::eType transport_type_value =
+      hmi_apis::Common_TransportType::USB_AOA;
+  const std::string connection_type = "USB_AOA";
+  const hmi_apis::Common_UserSetting::eType usb_transport_status =
+      hmi_apis::Common_UserSetting::DISABLED;
+
+  SmartObject& device_so = (*message_)[strings::msg_params][strings::device];
+  device_so[strings::transport_type] = transport_type_value;
+  device_so[strings::id] = kDeviceId;
+  device_so[strings::usb_transport_status] = usb_transport_status;
+
+  utils::SharedPtr<Command> command =
+      CreateCommand<hmi::OnDeviceConnectionStatusNotification>(message_);
+
+  EXPECT_CALL(mock_app_manager_, GetDeviceConnectionType(transport_type_value))
+      .WillOnce(Return(connection_type));
+  EXPECT_CALL(mock_policy_handler_,
+              OnDeviceConnectionStatus(kDeviceId, usb_transport_status));
   command->Run();
-  EXPECT_EQ(
-      static_cast<int32_t>(am::mobile_api::FunctionID::OnDriverDistractionID),
-      (*message)[am::strings::params][am::strings::function_id].asInt());
-  EXPECT_EQ(
-      static_cast<int32_t>(kAppId_),
-      (*message)[am::strings::params][am::strings::connection_key].asInt());
-  EXPECT_EQ(static_cast<int32_t>(am::MessageType::kNotification),
-            (*message)[am::strings::params][am::strings::message_type].asInt());
 }
 
 }  // namespace hmi_notifications_test
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 ef0cab13bf..0a9075b73e 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
@@ -903,7 +903,1258 @@ TEST_F(MessageHelperTest, SubscribeApplicationToSoftButton_CallFromApp) {
   EXPECT_CALL(*appSharedPtr,
               SubscribeToSoftButtons(function_id, SoftButtonID())).Times(1);
   MessageHelper::SubscribeApplicationToSoftButton(
-      message_params, appSharedPtr, function_id);
+      message_params, mock_app_, function_id);
+}
+
+TEST_F(MessageHelperTest, SendOnAppUnregNotificationToHMI) {
+  const bool kIsUnexpectedDisconnect = false;
+
+  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) {
+  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, 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][mobile_notification::syncp_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_F(MessageHelperTest,
+       SendUIChangeRegistrationRequestToHMI_AppNotValid_UNSUCCESS) {
+  MockApplicationSharedPtr mock_app;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  MessageHelper::SendUIChangeRegistrationRequestToHMI(
+      mock_app, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest,
+       SendUIChangeRegistrationRequestToHMI_NoAppTypes_UNSUCCESS) {
+  EXPECT_CALL(*mock_app_, app_hmi_types())
+      .WillOnce(Return(static_cast<smart_objects::SmartObject*>(NULL)));
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+  MessageHelper::SendUIChangeRegistrationRequestToHMI(
+      mock_app_, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendUIChangeRegistrationRequestToHMI_SUCCESS) {
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId_));
+
+  smart_objects::SmartObject dummy_app_types;
+  EXPECT_CALL(*mock_app_, app_hmi_types())
+      .WillRepeatedly(Return(&dummy_app_types));
+
+  const mobile_api::Language::eType kDummyLanguage =
+      mobile_api::Language::INVALID_ENUM;
+  EXPECT_CALL(*mock_app_, ui_language())
+      .WillRepeatedly(ReturnRef(kDummyLanguage));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendUIChangeRegistrationRequestToHMI(
+      mock_app_, mock_application_manager_);
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::UI_ChangeRegistration,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asInt());
+}
+
+TEST_F(MessageHelperTest, CreateDeviceListSO_EmptyDeviceList_SUCCESS) {
+  connection_handler::DeviceMap devices;
+
+  smart_objects::SmartObjectSPtr result(MessageHelper::CreateDeviceListSO(
+      devices,
+      *static_cast<policy::PolicyHandlerInterface*>(NULL),
+      mock_application_manager_));
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(smart_objects::SmartType_Array,
+            (*result)[strings::device_list].getType());
+  EXPECT_EQ(0u, (*result)[strings::device_list].length());
+}
+
+TEST_F(MessageHelperTest, CreateDeviceListSO_SUCCESS) {
+  connection_handler::DeviceMap devices;
+  policy_test::MockPolicyHandlerInterface policy_handler;
+
+  const uint32_t kDeviceHandle = 0u;
+  const std::string kDeviceName = "test_device";
+  connection_handler::Device device(kDeviceHandle, kDeviceName);
+
+  devices.insert(std::pair<uint32_t, connection_handler::Device>(0, device));
+
+  EXPECT_CALL(policy_handler, GetUserConsentForDevice(_))
+      .WillOnce(Return(policy::DeviceConsent::kDeviceAllowed));
+  EXPECT_CALL(mock_application_manager_, GetDeviceTransportType(_))
+      .WillOnce(Return(hmi_apis::Common_TransportType::INVALID_ENUM));
+
+  smart_objects::SmartObjectSPtr result(MessageHelper::CreateDeviceListSO(
+      devices, policy_handler, mock_application_manager_));
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(smart_objects::SmartType_Array,
+            (*result)[strings::device_list].getType());
+  EXPECT_TRUE(0 < (*result)[strings::device_list].length());
+}
+
+TEST_F(MessageHelperTest, CreateGetVehicleDataRequest_NoParams_SUCCESS) {
+  const uint32_t kCorrelationId = 1u;
+  const std::vector<std::string> kDummyMsgParams;
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::CreateGetVehicleDataRequest(
+      kCorrelationId, kDummyMsgParams, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(kCorrelationId,
+            (*result)[strings::params][strings::correlation_id].asUInt());
+}
+
+TEST_F(MessageHelperTest, CreateGetVehicleDataRequest_SUCCESS) {
+  const uint32_t kCorrelationId = 1u;
+  const std::string kTestParam = "test_param";
+  std::vector<std::string> msg_params;
+  msg_params.push_back(kTestParam);
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::CreateGetVehicleDataRequest(
+      kCorrelationId, msg_params, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(kCorrelationId,
+            (*result)[strings::params][strings::correlation_id].asUInt());
+  EXPECT_TRUE((*result)[strings::msg_params].keyExists(kTestParam));
+}
+
+TEST_F(MessageHelperTest, CreateHMIApplicationStruct_SUCCESS) {
+  protocol_handler_test::MockSessionObserver session_observer;
+  policy_test::MockPolicyHandlerInterface policy_handler;
+
+  smart_objects::SmartObject dummy_so(smart_objects::SmartType_Map);
+  dummy_so["dummy_param"] = 0;
+  EXPECT_CALL(*mock_app_, tts_name()).WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, vr_synonyms()).WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, ngn_media_screen_name())
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, app_hmi_types()).WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, is_media()).WillRepeatedly(Return(false));
+  EXPECT_CALL(*mock_app_, hmi_app_id()).WillRepeatedly(Return(0u));
+  EXPECT_CALL(*mock_app_, device()).WillRepeatedly(Return(0u));
+  EXPECT_CALL(*mock_app_, policy_app_id())
+      .WillRepeatedly(Return(std::string()));
+  const mobile_api::Language::eType kUiLanguage =
+      mobile_api::Language::INVALID_ENUM;
+  EXPECT_CALL(*mock_app_, ui_language()).WillRepeatedly(ReturnRef(kUiLanguage));
+
+  EXPECT_CALL(policy_handler, GetUserConsentForDevice(_))
+      .WillRepeatedly(Return(policy::DeviceConsent::kDeviceAllowed));
+  EXPECT_CALL(policy_handler, GetDeviceUSBTransportStatus(_))
+      .WillRepeatedly(Return(hmi_apis::Common_UserSetting::DISABLED));
+  EXPECT_CALL(session_observer, GetDataOnDeviceHandle(_, _, _, _, _))
+      .WillRepeatedly(Return(kNextHMICorrelationID));
+  EXPECT_CALL(mock_application_manager_, GetDeviceTransportType(_))
+      .WillRepeatedly(Return(hmi_apis::Common_TransportType::INVALID_ENUM));
+
+  const ::utils::custom_string::CustomString kAppName("app_name");
+  EXPECT_CALL(*mock_app_, name()).WillRepeatedly(ReturnRef(kAppName));
+  const std::string kAppIconPath("AppIconPath");
+  EXPECT_CALL(*mock_app_, app_icon_path())
+      .WillRepeatedly(ReturnRef(kAppIconPath));
+
+  smart_objects::SmartObject result;
+  EXPECT_TRUE(
+      MessageHelper::CreateHMIApplicationStruct(mock_app_,
+                                                session_observer,
+                                                policy_handler,
+                                                &result,
+                                                mock_application_manager_));
+
+  EXPECT_EQ(smart_objects::SmartType_Map, result.getType());
+  EXPECT_NE(result.length(), 0u);
+}
+
+TEST_F(MessageHelperTest, SendStopAudioPathThru_SUCCESS) {
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendStopAudioPathThru(mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::UI_EndAudioPassThru,
+            (*result)[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendSDLActivateAppResponse_SUCCESS) {
+  const uint32_t kCorrelationId = 0u;
+  const std::string kStrAppId("Application_ID");
+  policy::AppPermissions permissions(kStrAppId);
+  permissions.isSDLAllowed = true;
+  permissions.isAppPermissionsRevoked = false;
+  permissions.appRevoked = false;
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::SendSDLActivateAppResponse(
+      permissions, kCorrelationId, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::SDL_ActivateApp,
+            (*result)[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendPolicyUpdate_SUCCESS) {
+  const std::string kFilePath("file_path");
+  const int kTimeout = 0u;
+  std::vector<int> dummy_retries;
+  dummy_retries.push_back(5);
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendPolicyUpdate(
+      kFilePath, kTimeout, dummy_retries, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::BasicCommunication_PolicyUpdate,
+            (*result)[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendSystemRequestNotification_SUCCESS) {
+  smart_objects::SmartObject result;
+  EXPECT_CALL(mock_application_manager_, ManageMobileCommand(_, _))
+      .WillOnce(Return(true));
+
+  MessageHelper::SendSystemRequestNotification(
+      kConnectionKey_, result, mock_application_manager_);
+
+  EXPECT_EQ(mobile_apis::FunctionID::OnSystemRequestID,
+            result[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendShowRequestToHMI_NoApp_UNSUCCESS) {
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  ApplicationSharedPtr dummy_app;
+  MessageHelper::SendShowRequestToHMI(dummy_app, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendShowRequestToHMI_SUCCESS) {
+  smart_objects::SmartObject dummy_show_command(smart_objects::SmartType_Map);
+
+  EXPECT_CALL(*mock_app_, show_command())
+      .WillRepeatedly(Return(&dummy_show_command));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillRepeatedly(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendShowRequestToHMI(mock_app_, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::UI_Show,
+            (*result)[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest, SendAddVRCommandToHMI_SUCCESS) {
+  const uint32_t kCmdId = 0u;
+  const smart_objects::SmartObject kDummyVrCommands;
+
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId_));
+  EXPECT_CALL(*mock_app_, get_grammar_id()).WillRepeatedly(Return(0u));
+
+  EXPECT_CALL(mock_application_manager_, application(_))
+      .WillRepeatedly(Return(mock_app_));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillRepeatedly(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendAddVRCommandToHMI(
+      kCmdId, kDummyVrCommands, kAppId_, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::VR_AddCommand,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asUInt());
+}
+
+TEST_F(MessageHelperTest, SendAudioStopStream_SUCCESS) {
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillRepeatedly(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendAudioStopStream(kAppId_, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::Navigation_StopAudioStream,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asUInt());
+}
+
+TEST_F(MessageHelperTest, SendGetStatusUpdateResponse_SUCCESS) {
+  const uint32_t kCorrelationId = 0u;
+  const std::string kStatus("test_status");
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::SendGetStatusUpdateResponse(
+      kStatus, kCorrelationId, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::SDL_GetStatusUpdate,
+            (*result)[strings::params][strings::function_id].asInt());
+}
+
+TEST_F(MessageHelperTest,
+       SendChangeRegistrationRequestToHMI_NotValidAppPtr_UNSUCCESS) {
+  ApplicationSharedPtr app;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  MessageHelper::SendChangeRegistrationRequestToHMI(app,
+                                                    mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendChangeRegistrationRequestToHMI_SUCCESS) {
+  const mobile_api::Language::eType kAppLanguage = mobile_api::Language::RU_RU;
+
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId_));
+  EXPECT_CALL(*mock_app_, language()).WillRepeatedly(ReturnRef(kAppLanguage));
+  EXPECT_CALL(*mock_app_, ui_language())
+      .WillRepeatedly(ReturnRef(kAppLanguage));
+
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillRepeatedly(Return(kNextHMICorrelationID));
+  smart_objects::SmartObjectSPtr vr_command_result;
+  smart_objects::SmartObjectSPtr tts_command_result;
+  smart_objects::SmartObjectSPtr ui_command_result;
+  {
+    ::testing::InSequence sequence;
+    EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+        .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true)));
+    EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+        .WillOnce(DoAll(SaveArg<0>(&tts_command_result), Return(true)));
+    EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+        .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true)));
+  }
+  MessageHelper::SendChangeRegistrationRequestToHMI(mock_app_,
+                                                    mock_application_manager_);
+
+  ASSERT_TRUE(vr_command_result.valid());
+  ASSERT_TRUE(tts_command_result.valid());
+  ASSERT_TRUE(ui_command_result.valid());
+  EXPECT_EQ(
+      hmi_apis::FunctionID::VR_ChangeRegistration,
+      (*vr_command_result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::FunctionID::TTS_ChangeRegistration,
+      (*tts_command_result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      hmi_apis::FunctionID::UI_ChangeRegistration,
+      (*ui_command_result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(
+      kAppId_,
+      (*vr_command_result)[strings::msg_params][strings::app_id].asBool());
+  EXPECT_EQ(
+      kAppId_,
+      (*tts_command_result)[strings::msg_params][strings::app_id].asBool());
+  EXPECT_EQ(
+      kAppId_,
+      (*ui_command_result)[strings::msg_params][strings::app_id].asBool());
+}
+
+TEST_F(MessageHelperTest, SendAddSubMenuRequestToHMI_NoApp_UNSUCCESS) {
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  ApplicationSharedPtr dummy_app;
+  MessageHelper::SendAddSubMenuRequestToHMI(dummy_app,
+                                            mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest, SendAddSubMenuRequestToHMI_SUCCESS) {
+  SubMenuMap commands_map;
+  smart_objects::SmartObject command(smart_objects::SmartType_Map);
+  commands_map.insert(SubMenuMap::value_type(0u, &command));
+
+  EXPECT_CALL(*mock_app_, app_id()).WillRepeatedly(Return(kAppId_));
+  EXPECT_CALL(*mock_app_, sub_menu_map())
+      .WillRepeatedly(Return(DataAccessor<SubMenuMap>(commands_map, lock_)));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendAddSubMenuRequestToHMI(mock_app_,
+                                            mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asUInt());
+}
+
+TEST_F(MessageHelperTest,
+       SendAllOnButtonSubscriptionNotificationsForApp_NoApp_UNSUCCESS) {
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+
+  ApplicationSharedPtr dummy_app;
+  MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(
+      dummy_app, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest,
+       SendAllOnButtonSubscriptionNotificationsForApp_SUCCESS) {
+  EXPECT_CALL(*mock_app_, hmi_app_id()).WillRepeatedly(Return(kAppId_));
+
+  ButtonSubscriptions subscribed_buttons;
+  subscribed_buttons.insert(mobile_apis::ButtonName::CUSTOM_BUTTON);
+
+  EXPECT_CALL(*mock_app_, SubscribedButtons())
+      .WillRepeatedly(
+          Return(DataAccessor<ButtonSubscriptions>(subscribed_buttons, lock_)));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(
+      mock_app_, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::Buttons_OnButtonSubscription,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asUInt());
+}
+
+TEST_F(MessageHelperTest, SendAudioStartStream_SUCCESS) {
+  MockApplicationManagerSettings app_mngr_settings;
+
+  EXPECT_CALL(mock_application_manager_, get_settings())
+      .WillRepeatedly(ReturnRef(app_mngr_settings));
+
+  const std::string kAudioServerType("test_audio_server_type");
+  EXPECT_CALL(app_mngr_settings, audio_server_type())
+      .WillRepeatedly(ReturnRef(kAudioServerType));
+
+  const std::string kAudioStreamFile("test_audio_stream_file");
+  EXPECT_CALL(app_mngr_settings, audio_stream_file())
+      .WillRepeatedly(ReturnRef(kAudioStreamFile));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kNextHMICorrelationID));
+
+  MessageHelper::SendAudioStartStream(kAppId_, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  EXPECT_EQ(hmi_apis::FunctionID::Navigation_StartAudioStream,
+            (*result)[strings::params][strings::function_id].asInt());
+  EXPECT_EQ(kAppId_, (*result)[strings::msg_params][strings::app_id].asUInt());
+}
+
+TEST_F(MessageHelperTest, SendGetListOfPermissionsResponse_SUCCESS) {
+  std::vector<policy::FunctionalGroupPermission> permissions;
+  policy::CCSStatus ccs_status;
+  policy::FunctionalGroupPermission permission;
+  permission.state = policy::GroupConsent::kGroupAllowed;
+  permissions.push_back(permission);
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  const uint32_t kCorrelationId = 0u;
+  MessageHelper::SendGetListOfPermissionsResponse(
+      permissions, ccs_status, kCorrelationId, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  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 ccs_status_key = "ccsStatus";
+  EXPECT_TRUE(msg_params.keyExists(ccs_status_key));
+  EXPECT_TRUE(msg_params[ccs_status_key].empty());
+}
+
+TEST_F(MessageHelperTest,
+       SendGetListOfPermissionsResponse_CCSStatusNonEmpty_SUCCESS) {
+  using namespace policy;
+  using namespace smart_objects;
+
+  std::vector<policy::FunctionalGroupPermission> permissions;
+
+  CCSStatus ccs_status;
+  const int32_t entity_type_1 = 1;
+  const int32_t entity_id_1 = 2;
+  const EntityStatus entity_status_1 = kStatusOn;
+  const int32_t entity_type_2 = 3;
+  const int32_t entity_id_2 = 4;
+  const EntityStatus entity_status_2 = kStatusOff;
+  ccs_status.insert(CCSStatusItem(entity_type_1, entity_id_1, entity_status_1));
+  ccs_status.insert(CCSStatusItem(entity_type_2, entity_id_2, entity_status_2));
+
+  SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  const uint32_t correlation_id = 0u;
+  MessageHelper::SendGetListOfPermissionsResponse(
+      permissions, ccs_status, correlation_id, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+
+  SmartObject& msg_params = (*result)[strings::msg_params];
+  const std::string ccs_status_key = "ccsStatus";
+  EXPECT_TRUE(msg_params.keyExists(ccs_status_key));
+
+  SmartArray* status_array = msg_params[ccs_status_key].asArray();
+  EXPECT_TRUE(ccs_status.size() == status_array->size());
+
+  const std::string entityType = "entityType";
+  const std::string entityID = "entityID";
+  const std::string status = "status";
+  SmartObject item_1_so = SmartObject(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;
+
+  SmartObject item_2_so = SmartObject(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));
+}
+
+TEST_F(MessageHelperTest,
+       SendGetSystemInfoRequest_ExpectSendCorrectMessageToHMI) {
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+
+  MessageHelper::SendGetSystemInfoRequest(mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+  EXPECT_EQ(hmi_apis::FunctionID::BasicCommunication_GetSystemInfo,
+            (*result)[strings::params][strings::function_id].asInt());
+  CheckParamsOfMessage(result, false, true);
+}
+
+TEST_F(
+    MessageHelperTest,
+    SendGetUserFriendlyMessageResponseWithEmptyMessages_ExpectSendCorrectMessageToHMI) {
+  std::vector<policy::UserFriendlyMessage> msg;
+  CheckSendingGetUserFriendlyMessage(msg);
+}
+
+TEST_F(
+    MessageHelperTest,
+    SendGetUserFriendlyMessageResponseWithMessages_ExpectSendCorrectMessageToHMI) {
+  policy::UserFriendlyMessage arr[] = {
+      {"first_code"}, {"second_code"}, {"third_code"}};
+  std::vector<policy::UserFriendlyMessage> msg(arr, arr + 3);
+  CheckSendingGetUserFriendlyMessage(msg);
+}
+
+TEST_F(MessageHelperTest,
+       SendGlobalPropertiesToHMIApplicationIsNotValid_ExpectReturnFromMethod) {
+  MockApplicationSharedPtr mock_app;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_)).Times(0);
+  MessageHelper::SendGlobalPropertiesToHMI(mock_app, mock_application_manager_);
+}
+
+TEST_F(
+    MessageHelperTest,
+    SendGlobalPropertiesToHMIWithUIGlobalProperties_ExpectSendCorrectMessageToHMI) {
+  const uint8_t number_msg_params = 6;
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+  smart_objects::SmartObject dummy_so(smart_objects::SmartType_Map);
+  dummy_so["dummy_param"] = "dummy_param";
+  EXPECT_CALL(*mock_app_, vr_help_title())
+      .Times(3)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, vr_help()).Times(2).WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, keyboard_props())
+      .Times(2)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, menu_title())
+      .Times(2)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, menu_icon())
+      .Times(2)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId));
+  EXPECT_CALL(*mock_app_, help_prompt())
+      .WillOnce(Return(static_cast<smart_objects::SmartObject*>(NULL)));
+  EXPECT_CALL(*mock_app_, timeout_prompt())
+      .WillOnce(Return(static_cast<smart_objects::SmartObject*>(NULL)));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  MessageHelper::SendGlobalPropertiesToHMI(mock_app_,
+                                           mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+  smart_objects::SmartObject& global_properties_msg_params =
+      (*result)[strings::msg_params];
+
+  EXPECT_EQ((*result)[strings::params][strings::function_id].asInt(),
+            hmi_apis::FunctionID::UI_SetGlobalProperties);
+  CheckParamsOfMessage(result, true, true);
+
+  EXPECT_EQ(global_properties_msg_params.length(), number_msg_params);
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::vr_help_title));
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::vr_help));
+  EXPECT_TRUE(
+      global_properties_msg_params.keyExists(strings::keyboard_properties));
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::menu_title));
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::menu_icon));
+  std::set<std::string> keys = global_properties_msg_params.enumerate();
+  keys.erase(strings::app_id);
+  for (std::set<std::string>::iterator it = keys.begin(); it != keys.end();
+       ++it) {
+    EXPECT_TRUE(global_properties_msg_params[(*it)] == dummy_so);
+  }
+}
+
+TEST_F(
+    MessageHelperTest,
+    SendGlobalPropertiesToHMIWithTTSGlobalProperties_ExpectSendCorrectMessageToHMI) {
+  const uint8_t number_msg_params = 3;
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+  smart_objects::SmartObject dummy_so(smart_objects::SmartType_Map);
+  dummy_so["dummy_param"] = "dummy_param";
+  EXPECT_CALL(*mock_app_, vr_help_title())
+      .WillOnce(Return(static_cast<smart_objects::SmartObject*>(NULL)));
+  EXPECT_CALL(*mock_app_, vr_help())
+      .WillOnce(Return(static_cast<smart_objects::SmartObject*>(NULL)));
+  EXPECT_CALL(*mock_app_, help_prompt())
+      .Times(3)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, timeout_prompt())
+      .Times(2)
+      .WillRepeatedly(Return(&dummy_so));
+  EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId));
+
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  MessageHelper::SendGlobalPropertiesToHMI(mock_app_,
+                                           mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+  smart_objects::SmartObject& global_properties_msg_params =
+      (*result)[strings::msg_params];
+
+  EXPECT_EQ((*result)[strings::params][strings::function_id].asInt(),
+            hmi_apis::FunctionID::TTS_SetGlobalProperties);
+  CheckParamsOfMessage(result, true, true);
+  EXPECT_EQ(global_properties_msg_params.length(), number_msg_params);
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::help_prompt));
+  EXPECT_TRUE(global_properties_msg_params.keyExists(strings::timeout_prompt));
+  std::set<std::string> keys = global_properties_msg_params.enumerate();
+  keys.erase(strings::app_id);
+  for (std::set<std::string>::iterator it = keys.begin(); it != keys.end();
+       ++it) {
+    EXPECT_TRUE(global_properties_msg_params[(*it)] == dummy_so);
+  }
+}
+
+TEST_F(MessageHelperTest,
+       SendHashUpdateNotificationApplicationIsNotValid_ExpectReturnFromMethod) {
+  MockApplicationSharedPtr mock_app;
+  EXPECT_CALL(mock_application_manager_, application(_))
+      .WillOnce(Return(mock_app));
+  EXPECT_CALL(mock_application_manager_, ManageMobileCommand(_, _)).Times(0);
+  MessageHelper::SendHashUpdateNotification(kAppId, mock_application_manager_);
+}
+
+TEST_F(MessageHelperTest,
+       SendHashUpdateNotification_ExpectSendCorrectMessageToMobile) {
+  resumption::MockResumeCtrl mock_resume_ctrl;
+  EXPECT_CALL(mock_application_manager_, application(_))
+      .WillOnce(Return(mock_app_));
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageMobileCommand(_, _))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  EXPECT_CALL(mock_application_manager_, resume_controller())
+      .WillOnce(ReturnRef(mock_resume_ctrl));
+  EXPECT_CALL(mock_resume_ctrl, ApplicationsDataUpdated()).Times(1);
+  MessageHelper::SendHashUpdateNotification(kAppId, mock_application_manager_);
+  ASSERT_TRUE(result.valid());
+  EXPECT_EQ((*result)[strings::params][strings::function_id].asInt(),
+            mobile_apis::FunctionID::OnHashChangeID);
+  EXPECT_EQ((*result)[strings::params][strings::connection_key].asInt(),
+            kAppId);
+}
+
+TEST_F(MessageHelperTest, SendNaviStartStream_ExpectSendCorrectMessageToHMI) {
+  uint16_t video_streaming_port = 8080;
+  CheckParametersNaviStartStreamMessage(
+      "http://127.0.0.1:8080", "socket", "127.0.0.1", video_streaming_port);
+  CheckParametersNaviStartStreamMessage("pipe_name", "pipe", "pipe_name");
+  CheckParametersNaviStartStreamMessage("file_name", "file", "file_name");
+}
+
+TEST_F(MessageHelperTest, SendNaviStopStream_ExpectSendCorrectMessageToHMI) {
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, GetNextHMICorrelationID())
+      .WillOnce(Return(kCorrelationId));
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  MessageHelper::SendNaviStopStream(kAppId, mock_application_manager_);
+
+  ASSERT_TRUE(result.valid());
+  EXPECT_TRUE((*result)[strings::params].keyExists(strings::function_id));
+  EXPECT_EQ((*result)[strings::params][strings::function_id].asInt(),
+            hmi_apis::FunctionID::Navigation_StopStream);
+  CheckParamsOfMessage(result, true, true);
+}
+
+TEST_F(MessageHelperTest,
+       SendOnAppPermissionsChangedNotification_ExpectSendCorrectMessageToHMI) {
+  std::string policy_app_id("policyappid");
+  policy::AppPermissions dummy_permissions(policy_app_id);
+  dummy_permissions.appRevoked = true;
+  dummy_permissions.isAppPermissionsRevoked = true;
+  std::vector<policy::FunctionalGroupPermission> functional_group_permissions;
+  policy::FunctionalGroupPermission obj;
+  FillFunctionalGroupPermissionObj(obj,
+                                   "group_alias1",
+                                   "group_name1",
+                                   1,
+                                   policy::GroupConsent::kGroupAllowed);
+  functional_group_permissions.push_back(obj);
+  FillFunctionalGroupPermissionObj(obj,
+                                   "group_alias2",
+                                   "group_name2",
+                                   2,
+                                   policy::GroupConsent::kGroupDisallowed);
+  functional_group_permissions.push_back(obj);
+  FillFunctionalGroupPermissionObj(obj,
+                                   "group_alias3",
+                                   "group_name3",
+                                   3,
+                                   policy::GroupConsent::kGroupUndefined);
+  dummy_permissions.appRevokedPermissions = functional_group_permissions;
+  dummy_permissions.appPermissionsConsentNeeded = true;
+  dummy_permissions.appUnauthorized = true;
+  dummy_permissions.priority = "NORMAL";
+  dummy_permissions.requestTypeChanged = true;
+  std::vector<std::string> request_type(3, "dummy");
+  dummy_permissions.requestType = request_type;
+  smart_objects::SmartObjectSPtr result;
+  EXPECT_CALL(mock_application_manager_, ManageHMICommand(_))
+      .WillOnce(DoAll(SaveArg<0>(&result), Return(true)));
+  MessageHelper::SendOnAppPermissionsChangedNotification(
+      kAppId, dummy_permissions, mock_application_manager_);
+  ASSERT_TRUE(result.valid());
+  EXPECT_TRUE((*result)[strings::params].keyExists(strings::function_id));
+  EXPECT_EQ((*result)[strings::params][strings::function_id].asInt(),
+            hmi_apis::FunctionID::SDL_OnAppPermissionChanged);
+  CheckParamsOfMessage(result, true, false);
+  uint16_t number_msg_params = 8;
+  std::string app_revoked("appRevoked");
+  std::string is_app_permissions_revoked("isAppPermissionsRevoked");
+  std::string app_revoked_permissions("appRevokedPermissions");
+  std::string allowed("allowed");
+  std::string name("name");
+  std::string id("id");
+
+  EXPECT_EQ((*result)[strings::msg_params].length(), number_msg_params);
+  EXPECT_TRUE((*result)[strings::msg_params].keyExists(app_revoked));
+  EXPECT_TRUE((*result)[strings::msg_params][app_revoked].asBool());
+  EXPECT_TRUE(
+      (*result)[strings::msg_params].keyExists(is_app_permissions_revoked));
+  EXPECT_TRUE(
+      (*result)[strings::msg_params][is_app_permissions_revoked].asBool());
+  EXPECT_TRUE(
+      (*result)[strings::msg_params].keyExists(app_revoked_permissions));
+  EXPECT_TRUE(
+      ((*result)[strings::msg_params][app_revoked_permissions].length() ==
+       functional_group_permissions.size()));
+  uint16_t number_revoked_params = 3;
+  uint16_t number_revoked_params_without_allowed = 2;
+  smart_objects::SmartObject& revoked_items =
+      (*result)[strings::msg_params][app_revoked_permissions];
+  for (uint16_t i = 0; i < revoked_items.length(); ++i) {
+    if (policy::GroupConsent::kGroupUndefined ==
+        functional_group_permissions[i].state) {
+      EXPECT_TRUE(revoked_items[i].length() ==
+                  number_revoked_params_without_allowed);
+      EXPECT_FALSE(revoked_items[i].keyExists(allowed));
+    } else {
+      EXPECT_TRUE(revoked_items[i].length() == number_revoked_params);
+      EXPECT_TRUE(revoked_items[i].keyExists(allowed));
+      if (policy::kGroupAllowed == functional_group_permissions[i].state) {
+        EXPECT_TRUE(revoked_items[i][allowed].asBool());
+      } else {
+        EXPECT_FALSE(revoked_items[i][allowed].asBool());
+      }
+    }
+    EXPECT_TRUE(revoked_items[i].keyExists(name));
+    EXPECT_TRUE(revoked_items[i][name].asString() ==
+                functional_group_permissions[i].group_alias);
+    EXPECT_TRUE(revoked_items[i].keyExists(id));
+    EXPECT_TRUE(revoked_items[i][id].asInt() ==
+                functional_group_permissions[i].group_id);
+  }
+
+  std::string app_permissions_consent_needed("appPermissionsConsentNeeded");
+  std::string app_unauthorized("appUnauthorized");
+  std::string priority("priority");
+  EXPECT_TRUE(
+      (*result)[strings::msg_params].keyExists(app_permissions_consent_needed));
+  EXPECT_TRUE(
+      (*result)[strings::msg_params][app_permissions_consent_needed].asBool());
+  EXPECT_TRUE((*result)[strings::msg_params].keyExists(app_unauthorized));
+  EXPECT_TRUE((*result)[strings::msg_params][app_unauthorized].asBool());
+  EXPECT_TRUE((*result)[strings::msg_params].keyExists(priority));
+  EXPECT_EQ((*result)[strings::msg_params][priority].asInt(),
+            hmi_apis::Common_AppPriority::NORMAL);
+  EXPECT_TRUE((*result)[strings::msg_params].keyExists(strings::request_type));
+  smart_objects::SmartObject& request_types_array =
+      (*result)[strings::msg_params][strings::request_type];
+  EXPECT_TRUE(request_types_array.length() ==
+              dummy_permissions.requestType.size());
+  for (uint16_t i = 0; i < request_types_array.length(); ++i) {
+    EXPECT_TRUE(request_types_array[i].asString() ==
+                dummy_permissions.requestType[i]);
+  }
+>>>>>>> d63b94c... Changes CCS item implementation in order to support status as boolean
 }
 
 }  // namespace application_manager_test
diff --git a/src/components/include/application_manager/policies/policy_handler_interface.h b/src/components/include/application_manager/policies/policy_handler_interface.h
index 074a075e1f..80f67ef7cc 100644
--- a/src/components/include/application_manager/policies/policy_handler_interface.h
+++ b/src/components/include/application_manager/policies/policy_handler_interface.h
@@ -178,11 +178,13 @@ class PolicyHandlerInterface {
                              const DeviceInfo& device_info) = 0;
 
   /**
-   * @brief Store user-changed permissions consent to DB
-   * @param connection_key Connection key of application or 0, if permissions
-   * should be applied to all applications
-   * @param permissions User-changed group permissions consent
-   */
+ * @brief Processes data from OnAppPermissionConsent notification with
+ * permissions changes and CCS status changes done by user
+ * @param connection_key Connection key of application, 0 if no key has been
+ * provided
+ * @param permissions Groups permissions changes
+ * @param ccs_status Customer connectivity settings status changes
+ */
   virtual void OnAppPermissionConsent(const uint32_t connection_key,
                                       const PermissionConsent& permissions) = 0;
 
@@ -399,8 +401,21 @@ class PolicyHandlerInterface {
   virtual const std::string RemoteAppsUrl() const = 0;
 
  private:
+  /**
+   * @brief Processes data received via OnAppPermissionChanged notification
+   * from. Being started asyncronously from AppPermissionDelegate class.
+   * Sets updated permissions and CCS for registered applications and
+   * applications which already have appropriate group assigned which related to
+   * devices already known by policy
+   * @param connection_key Connection key of application, 0 if no key has been
+   * provided within notification
+   * @param ccs_status Customer connectivity settings changes to process
+   * @param permissions Permissions changes to process
+   */
   virtual void OnAppPermissionConsentInternal(
-      const uint32_t connection_key, PermissionConsent& permissions) = 0;
+      const uint32_t connection_key,
+      const CCSStatus& ccs_status,
+      PermissionConsent& out_permissions) = 0;
 
   friend class AppPermissionDelegate;
 };
diff --git a/src/components/include/policy/policy_external/policy/policy_listener.h b/src/components/include/policy/policy_external/policy/policy_listener.h
index de9d6eb8ef..b97e819d5f 100644
--- a/src/components/include/policy/policy_external/policy/policy_listener.h
+++ b/src/components/include/policy/policy_external/policy/policy_listener.h
@@ -115,12 +115,35 @@ class PolicyListener {
   virtual void OnCertificateUpdated(const std::string& certificate_data) = 0;
 
   /**
- * @brief Collects currently registered applications ids linked to their
- * device id
- * @return Collection of device_id-to-app_id links
- */
-  virtual void GetRegisteredLinks(
-      std::map<std::string, std::string>& out_links) const = 0;
+   * Notifies about changing HMI status
+   * @param device_id unique identifier of device
+   * @param policy_app_id unique identifier of application in policy
+   * @param hmi_level default HMI level for this application
+   */
+  virtual void OnUpdateHMIStatus(const std::string& device_id,
+                                 const std::string& policy_app_id,
+                                 const std::string& hmi_level) = 0;
+
+  /**
+   * Notifies about changing HMI status
+   * @param device_id unique identifier of device
+   * @param policy_app_id unique identifier of application in policy
+   * @param hmi_level default HMI level for this application
+   * @param device_rank device rank
+   */
+  virtual void OnUpdateHMIStatus(const std::string& device_id,
+                                 const std::string& policy_app_id,
+                                 const std::string& hmi_level,
+                                 const std::string& device_rank) = 0;
+#endif  // SDL_REMOTE_CONTROL
+
+    virtual KnownConsentsIds GetRegisteredApps() const = 0;
+  /**
+   * @brief Collects currently registered applications ids linked to their
+   * device id
+   * @return Collection of device_id-to-app_id links
+   */
+  virtual ApplicationsLinks GetRegisteredLinks() const = 0;
 };
 }  //  namespace policy
 #endif  // SRC_COMPONENTS_INCLUDE_POLICY_POLICY_LISTENER_H_
diff --git a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h
index 389befae6f..2b14f2226d 100644
--- a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h
+++ b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h
@@ -216,9 +216,10 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface {
                     policy::EndpointUrls& end_points));
 
  private:
-  MOCK_METHOD2(OnAppPermissionConsentInternal,
-               void(const uint32_t connection_key,
-                    policy::PermissionConsent& permissions));
+  MOCK_METHOD3(OnAppPermissionConsentInternal,
+               void(const uint32_t,
+                    const policy::CCSStatus&,
+                    policy::PermissionConsent&));
 };
 
 }  // namespace policy_test
diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
index 4bd9dc90ae..bc7be64aaa 100644
--- a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
+++ b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
@@ -83,8 +83,14 @@ class MockPolicyListener : public ::policy::PolicyListener {
   MOCK_METHOD1(OnCertificateUpdated, void(const std::string&));
   MOCK_CONST_METHOD2(SendOnAppPermissionsChanged,
                      void(const policy::AppPermissions&, const std::string&));
-  MOCK_CONST_METHOD1(GetRegisteredLinks,
-                     void(std::map<std::string, std::string>&));
+  MOCK_METHOD1(GetDevicesIds,
+               std::vector<std::string>(const std::string& policy_app_id));
+  MOCK_METHOD3(OnUpdateHMILevel,
+               void(const std::string& device_id,
+                    const std::string& policy_app_id,
+                    const std::string& hmi_level));
+  MOCK_CONST_METHOD0(GetRegisteredApps, policy::KnownConsentsIds());
+  MOCK_CONST_METHOD0(GetRegisteredLinks, policy::ApplicationsLinks());
 };
 
 }  // namespace policy_test
diff --git a/src/components/policy/policy_external/include/policy/policy_helper.h b/src/components/policy/policy_external/include/policy/policy_helper.h
index 9f8151e29f..10d6908b14 100644
--- a/src/components/policy/policy_external/include/policy/policy_helper.h
+++ b/src/components/policy/policy_external/include/policy/policy_helper.h
@@ -75,62 +75,128 @@ struct CompareGroupName {
 bool operator!=(const policy_table::ApplicationParams& first,
                 const policy_table::ApplicationParams& second);
 
-/*
+/**
  * @brief Helper struct for checking changes of application policies, which
  * come with update along with current data snapshot
- * In case of policies changed for some application, current data will be
- * updated and notification will be sent to application
+ * @param pm Pointer to PolicyManager instance
+ * @param update Shared pointer to policy table update received
+ * @param snapshot Shared pointer to current policy table copy
+ * @param out_results Collection of check result
  */
 struct CheckAppPolicy {
   CheckAppPolicy(PolicyManagerImpl* pm,
                  const utils::SharedPtr<policy_table::Table> update,
-                 const utils::SharedPtr<policy_table::Table> snapshot);
+                 const utils::SharedPtr<policy_table::Table> snapshot,
+                 CheckAppPolicyResults& out_results);
+
   bool operator()(const AppPoliciesValueType& app_policy);
 
  private:
-  enum PermissionsCheckResult {
-    RESULT_NO_CHANGES,
-    RESULT_APP_REVOKED,
-    RESULT_NICKNAME_MISMATCH,
-    RESULT_PERMISSIONS_REVOKED,
-    RESULT_CONSENT_NEEDED,
-    RESULT_CONSENT_NOT_REQIURED,
-    RESULT_PERMISSIONS_REVOKED_AND_CONSENT_NEEDED,
-    RESULT_REQUEST_TYPE_CHANGED
-  };
-
+  /**
+   * @brief Sets pending values to be notified to the system (depends on HMI
+   * level of application) with SDL.ActivateApp or OnAppPermissionsChanged
+   * notification
+   * @param app_policy Reference to updated application policy
+   * @param result Result of check of updated policy
+   */
   void SetPendingPermissions(const AppPoliciesValueType& app_policy,
                              PermissionsCheckResult result) const;
+  /**
+   * @brief Analyzes updated application policy whether any changes received. If
+   * yes - provides appropriate result code
+   * @param app_policy Reference to updated application policy
+   * @return Result code according to changes in updated policy
+   */
   PermissionsCheckResult CheckPermissionsChanges(
       const AppPoliciesValueType& app_policy) const;
+  /**
+   * @brief Checks whether updated policy has groups revoked, i.e. absent in
+   * compare to current one
+   * @param app_policy Reference to updated policy
+   * @param revoked_groups List of revoked groups if any
+   * @return True if there are revoked groups, otherwise - false
+   */
   bool HasRevokedGroups(const AppPoliciesValueType& app_policy,
                         policy_table::Strings* revoked_groups = NULL) const;
+  /**
+   * @brief Checks whether updated application policy has new group in compare
+   * to current one
+   * @param app_policy Reference to updated application policy
+   * @param new_groups List of new groups if any
+   * @return True if new groups found, otherwise - false
+   */
   bool HasNewGroups(const AppPoliciesValueType& app_policy,
                     policy_table::Strings* new_groups = NULL) const;
+  /**
+   * @brief Checks whether updated policy has groups which require user consent
+   * @param app_policy Reference to updated application policy
+   * @return True if has groups requiring user consents, otherwise - false
+   */
   bool HasConsentNeededGroups(const AppPoliciesValueType& app_policy) const;
+  /**
+   * @brief Gets revoked groups parameters from current policies
+   * @param app_policy Reference to updated application policy
+   * @return List of revoked groups with their parameters
+   */
   std::vector<FunctionalGroupPermission> GetRevokedGroups(
       const AppPoliciesValueType& app_policy) const;
+  /**
+   * @brief Removes consents for revoked groups of application
+   * @param app_policy Reference to updated application policy
+   * @param revoked_groups List of revoked groups with parameters to remove
+   * consents if any exists
+   */
   void RemoveRevokedConsents(
       const AppPoliciesValueType& app_policy,
       const std::vector<FunctionalGroupPermission>& revoked_groups) const;
+  /**
+   * @brief Checks whether application is present in current policy table,
+   * since update can be processed only for application known by policy while
+   * it sent update request
+   * @param application_id Application id
+   * @return True if application is known, otherwise - false
+   */
   bool IsKnownAppication(const std::string& application_id) const;
-  void NotifySystem(const AppPoliciesValueType& app_policy) const;
-  void SendPermissionsToApp(const AppPoliciesValueType& app_policy) const;
+  /**
+   * @brief Checks whether application is revoked by backend, i.e. has 'null'
+   * for policies parameters
+   * @param app_policy Reference to updated application policy
+   * @return True if application is revoked, otherwise - false
+   */
   bool IsAppRevoked(const AppPoliciesValueType& app_policy) const;
+  /**
+   * @brief Checks whether there such application is registered and has correct
+   * nickname
+   * @param app_policy Reference to updated application policy
+   * @return  True if there is nickname mismatch, otherwise - false
+   */
   bool NicknamesMatch(const AppPoliciesValueType& app_policy) const;
   /**
+   * @brief Adds result of check of current application policy with updated one
+   * @param app_id Application id
+   * @param result Result value
+   */
+  void AddResult(const std::string& app_id, PermissionsCheckResult result);
+  /**
    * @brief Allows to check if appropriate group requires any consent.
    * @param group_name the group for which consent will be checked.
    * @return true if consent is required, false otherwise.
    */
   bool IsConsentRequired(const std::string& app_id,
                          const std::string& group_name) const;
+  /**
+   * @brief Checks whether RequestTypes of application have been changed by
+   * udpated
+   * @param app_policy Reference to updated application policy
+   * @return True if changed, otherwise - false
+   */
   bool IsRequestTypeChanged(const AppPoliciesValueType& app_policy) const;
 
  private:
   PolicyManagerImpl* pm_;
   const utils::SharedPtr<policy_table::Table> update_;
   const utils::SharedPtr<policy_table::Table> snapshot_;
+  CheckAppPolicyResults& out_results_;
 };
 
 /*
diff --git a/src/components/policy/policy_external/include/policy/policy_manager_impl.h b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
index dcca92cf07..239d46388c 100644
--- a/src/components/policy/policy_external/include/policy/policy_manager_impl.h
+++ b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
@@ -211,23 +211,42 @@ class PolicyManagerImpl : public PolicyManager {
   AppIdURL RetrySequenceUrl(const struct RetrySequenceURL& rs,
                             const EndpointUrls& urls) const OVERRIDE;
 
+  bool SetExternalConsentStatus(const ExternalConsentStatus& status) OVERRIDE;
+  ExternalConsentStatus GetExternalConsentStatus() OVERRIDE;
+
  protected:
   virtual utils::SharedPtr<policy_table::Table> Parse(
       const BinaryMessage& pt_content);
 
  private:
   void CheckTriggers();
-  /*
-   * @brief Checks policy table update along with current data for any changes
-   * in assigned functional group list of application
-   *
-   * @param Policy table update struct
+
+  /**
+   * @brief Compares current applications policies to the updated one and
+   * returns apporopriate result codes per application, which that are being
+   * processed by sending notification to applications registered and to the
+   * system
+   * @param update Shared pointer to policy table udpate
+   * @param snapshot Shared pointer to current copy of policy table
+   * @return Collection per-application results
    */
-  void CheckPermissionsChanges(
+  CheckAppPolicyResults CheckPermissionsChanges(
       const utils::SharedPtr<policy_table::Table> update,
       const utils::SharedPtr<policy_table::Table> snapshot);
 
   /**
+   * @brief Processes results from policy table update analysis done by
+   * CheckPermissionsChanges() by sending OnPermissionChange and
+   * OnAppPermissionChanged notifications
+   * @param results Collection of per-application results
+   * @param app_policies Reference to updated application policies section as
+   * a data source for generating notifications data
+   */
+  void ProcessAppPolicyCheckResults(
+      const CheckAppPolicyResults& results,
+      const policy_table::ApplicationPolicies& app_policies);
+
+  /**
    * @brief Fill structure to be sent with OnPermissionsChanged notification
    *
    * @param Policy table struct, which contains rpc functional groups data
@@ -394,8 +413,82 @@ class PolicyManagerImpl : public PolicyManager {
       GroupsNames& out_allowed_groups,
       GroupsNames& out_disallowed_groups) const;
 
-  bool SetExternalConsentStatus(const ExternalConsentStatus& status) OVERRIDE;
-  ExternalConsentStatus GetExternalConsentStatus() OVERRIDE;
+  /**
+   * @brief Notify application about its permissions changes by preparing and
+   * sending OnPermissionsChanged notification
+   * @param policy_app_id Application id to send notification to
+   * @param app_group_permissons Current permissions for groups assigned to
+   * application
+   */
+  void NotifyPermissionsChanges(
+      const std::string& policy_app_id,
+      const std::vector<FunctionalGroupPermission>& app_group_permissions);
+
+  /**
+   * @brief Processes updated CCS status received via OnAppPermissionConsent
+   * notification by updating user consents and CCS consents for registered and
+   * known before by policy table (must have any user consent records)
+   * @param groups_by_status Collection of CCS entities with their statuses
+   */
+  void ProcessCCSStatusUpdate(const GroupsByCCSStatus& groups_by_status);
+
+  /**
+   * @brief Processes CCS status for application registered afterward, so its
+   * user consents (if any) and CCS consents (if any) will be updated
+   * appropiately to current CCS status stored by policy table
+   * @param application_id Application id
+   */
+  void ProcessCCSStatusForApp(const std::string& application_id);
+  /**
+   * @brief Directly updates user consent and CCS consents (if any) for
+   * application if it has assigned any of group from allowed or disallowed
+   * lists
+   * @param device_id Device id which is linked to application id
+   * @param application_id Application id
+   * @param allowed_groups List of group names allowed by current CCS status
+   * @param disallowed_groups List of group names disallwed by current CCS
+   * status
+   */
+  void UpdateAppConsentWithCCS(const std::string& device_id,
+                               const std::string& application_id,
+                               const GroupsNames& allowed_groups,
+                               const GroupsNames& disallowed_groups);
+
+  typedef policy_table::ApplicationPolicies::value_type AppPoliciesValueType;
+
+  /**
+   * @brief Notifies system by sending OnAppPermissionChanged notification
+   * @param app_policy Reference to application policy
+   */
+  void NotifySystem(const AppPoliciesValueType& app_policy) const;
+
+  /**
+   * @brief Sends OnPermissionChange notification to application if its
+   * currently registered
+   * @param app_policy Reference to application policy
+   */
+  void SendPermissionsToApp(const AppPoliciesValueType& app_policy);
+
+  /**
+   * @brief Gets groups names from collection of groups permissions
+   * @param app_group_permissions Collection of groups permissions
+   * @return Collection of group names
+   */
+  policy_table::Strings GetGroupsNames(
+      const std::vector<FunctionalGroupPermission>& app_group_permissions)
+      const;
+
+  /**
+   * @brief Calculates consents for groups based on mapped CCS entities statuses
+   * and groups containers where entities have been found
+   * @param groups_by_ccs CCS entities mapped to functional groups names and
+   * their containters where this entity has been found
+   * @param out_allowed_groups List of groups allowed by CCS status
+   * @param out_disallowed_groups List of groups disallowed by CCS status
+   */
+  void CalculateGroupsConsentFromCCS(const GroupsByCCSStatus& groups_by_ccs,
+                                     GroupsNames& out_allowed_groups,
+                                     GroupsNames& out_disallowed_groups) const;
 
   PolicyListener* listener_;
 
@@ -403,7 +496,14 @@ class PolicyManagerImpl : public PolicyManager {
   CacheManagerInterfaceSPtr cache_;
   sync_primitives::Lock apps_registration_lock_;
   sync_primitives::Lock app_permissions_diff_lock_;
-  std::map<std::string, AppPermissions> app_permissions_diff_;
+
+  /**
+   * @brief Collection of parameters to be reported to the system with
+   * SDL.ActivateApp response or OnAppPermissionsChanged notification
+   * Being set during policy table update processing
+   */
+  typedef std::map<std::string, AppPermissions> PendingPermissions;
+  PendingPermissions app_permissions_diff_;
 
   /**
    * Timeout to wait response with UpdatePT
diff --git a/src/components/policy/policy_external/include/policy/policy_types.h b/src/components/policy/policy_external/include/policy/policy_types.h
index ad8ebc4c9c..73bd76f0ac 100644
--- a/src/components/policy/policy_external/include/policy/policy_types.h
+++ b/src/components/policy/policy_external/include/policy/policy_types.h
@@ -38,6 +38,7 @@
 #include <vector>
 #include <map>
 #include <set>
+#include <utility>
 #include "utils/shared_ptr.h"
 #include "utils/helpers.h"
 namespace policy {
diff --git a/src/components/policy/policy_external/src/cache_manager.cc b/src/components/policy/policy_external/src/cache_manager.cc
index ba71e5dc6f..b7f4f553d7 100644
--- a/src/components/policy/policy_external/src/cache_manager.cc
+++ b/src/components/policy/policy_external/src/cache_manager.cc
@@ -36,6 +36,9 @@
 #include <functional>
 #include <ctime>
 #include <cmath>
+#include <utility>
+#include <string>
+#include <vector>
 
 #include "utils/file_system.h"
 #include "json/reader.h"
diff --git a/src/components/policy/policy_external/src/policy_helper.cc b/src/components/policy/policy_external/src/policy_helper.cc
index a477ca55d2..f4ab80d6f7 100644
--- a/src/components/policy/policy_external/src/policy_helper.cc
+++ b/src/components/policy/policy_external/src/policy_helper.cc
@@ -123,8 +123,12 @@ bool operator!=(const policy_table::ApplicationParams& first,
 CheckAppPolicy::CheckAppPolicy(
     PolicyManagerImpl* pm,
     const utils::SharedPtr<policy_table::Table> update,
-    const utils::SharedPtr<policy_table::Table> snapshot)
-    : pm_(pm), update_(update), snapshot_(snapshot) {}
+    const utils::SharedPtr<policy_table::Table> snapshot,
+    CheckAppPolicyResults& out_results)
+    : pm_(pm)
+    , update_(update)
+    , snapshot_(snapshot)
+    , out_results_(out_results) {}
 
 bool policy::CheckAppPolicy::HasRevokedGroups(
     const policy::AppPoliciesValueType& app_policy,
@@ -262,37 +266,6 @@ bool CheckAppPolicy::IsKnownAppication(
   return !(current_policies.end() == current_policies.find(application_id));
 }
 
-void policy::CheckAppPolicy::NotifySystem(
-    const policy::AppPoliciesValueType& app_policy) const {
-  pm_->listener()->OnPendingPermissionChange(app_policy.first);
-}
-
-void CheckAppPolicy::SendPermissionsToApp(
-    const AppPoliciesValueType& app_policy) const {
-  const std::string app_id = app_policy.first;
-
-  const std::string device_id = pm_->GetCurrentDeviceId(app_id);
-  if (device_id.empty()) {
-    LOG4CXX_WARN(logger_,
-                 "Couldn't find device info for application id: " << app_id);
-    return;
-  }
-  std::vector<FunctionalGroupPermission> group_permissons;
-  pm_->GetPermissionsForApp(device_id, app_id, group_permissons);
-
-  Permissions notification_data;
-  pm_->PrepareNotificationData(update_->policy_table.functional_groupings,
-                               app_policy.second.groups,
-                               group_permissons,
-                               notification_data);
-
-  LOG4CXX_INFO(logger_, "Send notification for application_id: " << app_id);
-  pm_->listener()->OnPermissionsUpdated(
-      app_id,
-      notification_data,
-      policy_table::EnumToJsonString(app_policy.second.default_hmi));
-}
-
 bool CheckAppPolicy::IsAppRevoked(
     const AppPoliciesValueType& app_policy) const {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -321,6 +294,11 @@ bool CheckAppPolicy::NicknamesMatch(
   return true;
 }
 
+void CheckAppPolicy::AddResult(const std::string& app_id,
+                               PermissionsCheckResult result) {
+  out_results_.insert(std::make_pair(app_id, result));
+}
+
 bool CheckAppPolicy::operator()(const AppPoliciesValueType& app_policy) {
   const std::string app_id = app_policy.first;
 
@@ -332,13 +310,13 @@ bool CheckAppPolicy::operator()(const AppPoliciesValueType& app_policy) {
 
   if (!IsPredefinedApp(app_policy) && IsAppRevoked(app_policy)) {
     SetPendingPermissions(app_policy, RESULT_APP_REVOKED);
-    NotifySystem(app_policy);
+    AddResult(app_id, RESULT_APP_REVOKED);
     return true;
   }
 
   if (!IsPredefinedApp(app_policy) && !NicknamesMatch(app_policy)) {
     SetPendingPermissions(app_policy, RESULT_NICKNAME_MISMATCH);
-    NotifySystem(app_policy);
+    AddResult(app_id, RESULT_NICKNAME_MISMATCH);
     return true;
   }
 
@@ -346,13 +324,14 @@ bool CheckAppPolicy::operator()(const AppPoliciesValueType& app_policy) {
 
   if (!IsPredefinedApp(app_policy) && IsRequestTypeChanged(app_policy)) {
     SetPendingPermissions(app_policy, RESULT_REQUEST_TYPE_CHANGED);
-    NotifySystem(app_policy);
+    AddResult(app_id, RESULT_REQUEST_TYPE_CHANGED);
   }
 
   if (RESULT_NO_CHANGES == result) {
     LOG4CXX_INFO(logger_,
                  "Permissions for application:" << app_id
                                                 << " wasn't changed.");
+    AddResult(app_id, result);
     return true;
   }
 
@@ -362,13 +341,9 @@ bool CheckAppPolicy::operator()(const AppPoliciesValueType& app_policy) {
 
   if (!IsPredefinedApp(app_policy) && RESULT_CONSENT_NOT_REQIURED != result) {
     SetPendingPermissions(app_policy, result);
-    NotifySystem(app_policy);
+    AddResult(app_id, result);
   }
 
-  // Don't sent notification for predefined apps (e.g. default, device etc.)
-  if (!IsPredefinedApp(app_policy)) {
-    SendPermissionsToApp(app_policy);
-  }
   return true;
 }
 
@@ -439,8 +414,7 @@ void policy::CheckAppPolicy::SetPendingPermissions(
   pm_->app_permissions_diff_lock_.Release();
 }
 
-policy::CheckAppPolicy::PermissionsCheckResult
-policy::CheckAppPolicy::CheckPermissionsChanges(
+PermissionsCheckResult CheckAppPolicy::CheckPermissionsChanges(
     const policy::AppPoliciesValueType& app_policy) const {
   bool has_revoked_groups = HasRevokedGroups(app_policy);
 
diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc
index 4ce18d3c79..6e0ccb2fb6 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -36,6 +36,8 @@
 #include <queue>
 #include <iterator>
 #include <limits>
+#include <vector>
+#include <functional>
 #include "json/reader.h"
 #include "json/writer.h"
 #include "policy/policy_table.h"
@@ -55,6 +57,127 @@ policy::PolicyManager* CreateManager() {
 void DeleteManager(policy::PolicyManager* pm) {
   delete pm;
 }
+namespace {
+
+/**
+ * @brief Extracts group name from group permission structure
+ */
+struct GroupNamesAppender
+    : public std::unary_function<void,
+                                 const policy::FunctionalGroupPermission&> {
+  GroupNamesAppender(policy_table::Strings& names) : names_(names) {}
+
+  void operator()(const policy::FunctionalGroupPermission& value) {
+    names_.push_back(value.group_name);
+  }
+
+ private:
+  policy_table::Strings& names_;
+};
+
+/**
+ * @brief Updates permission state of input group permission value in case
+ * group name is found within allowed or disallowed groups lists
+ * Also collects matched groups names to separate collection for futher
+ * processing
+ */
+struct ConsentsUpdater
+    : public std::unary_function<void, policy::FunctionalGroupPermission&> {
+  ConsentsUpdater(
+      const policy::GroupsNames& allowed,
+      const policy::GroupsNames& disallowed,
+      std::vector<policy::FunctionalGroupPermission>& out_ccs_matches)
+      : allowed_(allowed)
+      , disallowed_(disallowed)
+      , out_ccs_matches_(out_ccs_matches) {}
+
+  void operator()(policy::FunctionalGroupPermission& value) {
+    using namespace policy;
+
+    GroupsNames::iterator it_disallowed =
+        std::find(disallowed_.begin(), disallowed_.end(), value.group_name);
+
+    if (disallowed_.end() != it_disallowed) {
+      value.state = kGroupDisallowed;
+      out_ccs_matches_.push_back(value);
+      return;
+    }
+
+    GroupsNames::iterator it_allowed =
+        std::find(allowed_.begin(), allowed_.end(), value.group_name);
+
+    if (allowed_.end() != it_allowed) {
+      value.state = kGroupAllowed;
+      out_ccs_matches_.push_back(value);
+    }
+  }
+
+ private:
+  const policy::GroupsNames& allowed_;
+  const policy::GroupsNames& disallowed_;
+  std::vector<policy::FunctionalGroupPermission>& out_ccs_matches_;
+};
+
+/**
+ * @brief Checks whether CCS entity status is the same as name of group
+ * container where entity has been found in. In case of match group is added to
+ * 'disallowed' list, otherwise - to 'allowed' one.
+ * E.g. if entity has "ON" status and is found in
+ * 'disallowed_by_ccs_entities_on' it will be added to 'disallowed'. If it has
+ * been found in 'disallowed_by_ccs_entities_off' than group is added to
+ * 'allowed' list.
+ */
+struct GroupChecker
+    : std::unary_function<void,
+                          policy::GroupsByCCSStatus::mapped_type::value_type> {
+  GroupChecker(const policy::EntityStatus entity_status,
+               policy::GroupsNames& out_allowed,
+               policy::GroupsNames& out_disallowed)
+      : entity_status_(entity_status)
+      , out_allowed_(out_allowed)
+      , out_disallowed_(out_disallowed) {}
+
+  void operator()(
+      const policy::GroupsByCCSStatus::mapped_type::value_type value) {
+    using namespace policy;
+
+    const std::string group_name = value.first;
+
+    if ((value.second && (kStatusOn == entity_status_)) ||
+        (!value.second && (kStatusOff == entity_status_))) {
+      out_disallowed_.insert(group_name);
+    } else {
+      out_allowed_.insert(group_name);
+    }
+  }
+
+ private:
+  const policy::EntityStatus entity_status_;
+  policy::GroupsNames& out_allowed_;
+  policy::GroupsNames& out_disallowed_;
+};
+
+/**
+ * @brief Sorts groups for 'allowed' and 'disallowed' by CCS entities statuses.
+ * Wraps GroupChecker logic.
+ */
+struct GroupSorter
+    : std::unary_function<void, const policy::GroupsByCCSStatus::value_type&> {
+  GroupSorter(policy::GroupsNames& out_allowed,
+              policy::GroupsNames& out_disallowed)
+      : out_allowed_(out_allowed), out_disallowed_(out_disallowed) {}
+
+  void operator()(const policy::GroupsByCCSStatus::value_type& value) {
+    GroupChecker checker(value.first.status_, out_allowed_, out_disallowed_);
+    std::for_each(value.second.begin(), value.second.end(), checker);
+  }
+
+ private:
+  policy::GroupsNames& out_allowed_;
+  policy::GroupsNames& out_disallowed_;
+};
+
+}  // namespace
 
 namespace {
 
@@ -272,7 +395,8 @@ bool PolicyManagerImpl::LoadPT(const std::string& file,
     // groups, which had been present before are absent in PTU and will be
     // removed after update. So in case of revoked groups system has to know
     // names and ids of revoked groups before they will be removed.
-    CheckPermissionsChanges(pt_update, policy_table_snapshot);
+    CheckAppPolicyResults results =
+        CheckPermissionsChanges(pt_update, policy_table_snapshot);
 
     // Replace current data with updated
     if (!cache_->ApplyUpdate(*pt_update)) {
@@ -280,6 +404,15 @@ bool PolicyManagerImpl::LoadPT(const std::string& file,
       return false;
     }
 
+    CCSStatus status = cache_->GetCCSStatus();
+    GroupsByCCSStatus groups_by_status =
+        cache_->GetGroupsWithSameEntities(status);
+
+    ProcessCCSStatusUpdate(groups_by_status);
+
+    ProcessAppPolicyCheckResults(
+        results, pt_update->policy_table.app_policies_section.apps);
+
     listener_->OnCertificateUpdated(
         *(pt_update->policy_table.module_config.certificate));
 
@@ -304,11 +437,7 @@ bool PolicyManagerImpl::LoadPT(const std::string& file,
   return true;
 }
 
-std::string PolicyManagerImpl::GetLockScreenIconUrl() const {
-  return cache_->GetLockScreenIconUrl();
-}
-
-void PolicyManagerImpl::CheckPermissionsChanges(
+CheckAppPolicyResults PolicyManagerImpl::CheckPermissionsChanges(
     const utils::SharedPtr<policy_table::Table> pt_update,
     const utils::SharedPtr<policy_table::Table> snapshot) {
   LOG4CXX_INFO(logger_, "Checking incoming permissions.");
@@ -317,9 +446,65 @@ void PolicyManagerImpl::CheckPermissionsChanges(
   // to actual values of default section
   UnwrapAppPolicies(pt_update->policy_table.app_policies_section.apps);
 
+  CheckAppPolicyResults out_results;
   std::for_each(pt_update->policy_table.app_policies_section.apps.begin(),
                 pt_update->policy_table.app_policies_section.apps.end(),
-                CheckAppPolicy(this, pt_update, snapshot));
+                CheckAppPolicy(this, pt_update, snapshot, out_results));
+
+  return out_results;
+}
+
+void PolicyManagerImpl::ProcessAppPolicyCheckResults(
+    const CheckAppPolicyResults& results,
+    const policy_table::ApplicationPolicies& app_policies) {
+  CheckAppPolicyResults::const_iterator it_results = results.begin();
+
+  for (; results.end() != it_results; ++it_results) {
+    const policy_table::ApplicationPolicies::const_iterator app_policy =
+        app_policies.find(it_results->first);
+
+    if (app_policies.end() == app_policy) {
+      continue;
+    }
+
+    if (IsPredefinedApp(*app_policy)) {
+      continue;
+    }
+
+    switch (it_results->second) {
+      case RESULT_NO_CHANGES:
+        continue;
+      case RESULT_APP_REVOKED:
+        NotifySystem(*app_policy);
+        continue;
+      case RESULT_NICKNAME_MISMATCH:
+        NotifySystem(*app_policy);
+        continue;
+      case RESULT_CONSENT_NEEDED:
+      case RESULT_PERMISSIONS_REVOKED_AND_CONSENT_NEEDED: {
+        // Post-check after CCS consent changes
+        const std::string policy_app_id = app_policy->first;
+        if (!IsConsentNeeded(policy_app_id)) {
+          sync_primitives::AutoLock lock(app_permissions_diff_lock_);
+
+          PendingPermissions::iterator app_id_diff =
+              app_permissions_diff_.find(policy_app_id);
+
+          if (app_permissions_diff_.end() != app_id_diff) {
+            app_id_diff->second.appPermissionsConsentNeeded = false;
+          }
+        }
+      } break;
+      case RESULT_CONSENT_NOT_REQIURED:
+      case RESULT_PERMISSIONS_REVOKED:
+      case RESULT_REQUEST_TYPE_CHANGED:
+        break;
+      default:
+        continue;
+    }
+    NotifySystem(*app_policy);
+    SendPermissionsToApp(*app_policy);
+  }
 }
 
 void PolicyManagerImpl::PrepareNotificationData(
@@ -457,14 +642,7 @@ void PolicyManagerImpl::CheckPermissions(const PTString& app_id,
     policy_table::FunctionalGroupings functional_groupings;
     cache_->GetFunctionalGroupings(functional_groupings);
 
-    std::vector<FunctionalGroupPermission>::const_iterator it =
-        app_group_permissions.begin();
-    std::vector<FunctionalGroupPermission>::const_iterator it_end =
-        app_group_permissions.end();
-    policy_table::Strings app_groups;
-    for (; it != it_end; ++it) {
-      app_groups.push_back((*it).group_name);
-    }
+    policy_table::Strings app_groups = GetGroupsNames(app_group_permissions);
 
     // Undefined groups (without user consent) disallowed by default, since
     // OnPermissionsChange notification has no "undefined" section
@@ -605,6 +783,16 @@ bool PolicyManagerImpl::ResetUserConsent() {
   return result;
 }
 
+policy_table::Strings PolicyManagerImpl::GetGroupsNames(
+    const std::vector<FunctionalGroupPermission>& app_group_permissions) const {
+  policy_table::Strings app_groups;
+  GroupNamesAppender appender(app_groups);
+  std::for_each(
+      app_group_permissions.begin(), app_group_permissions.end(), appender);
+
+  return app_groups;
+}
+
 void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
     const std::string& application_id) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -622,14 +810,7 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
   policy_table::FunctionalGroupings functional_groupings;
   cache_->GetFunctionalGroupings(functional_groupings);
 
-  policy_table::Strings app_groups;
-  std::vector<FunctionalGroupPermission>::const_iterator it =
-      app_group_permissions.begin();
-  std::vector<FunctionalGroupPermission>::const_iterator it_end =
-      app_group_permissions.end();
-  for (; it != it_end; ++it) {
-    app_groups.push_back((*it).group_name);
-  }
+  policy_table::Strings app_groups = GetGroupsNames(app_group_permissions);
 
   Permissions notification_data;
   PrepareNotificationData(functional_groupings,
@@ -789,7 +970,7 @@ void PolicyManagerImpl::CheckPendingPermissionsChanges(
     const std::vector<FunctionalGroupPermission>& current_permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(app_permissions_diff_lock_);
-  std::map<std::string, AppPermissions>::iterator it_pending =
+  PendingPermissions::iterator it_pending =
       app_permissions_diff_.find(policy_app_id);
   if (app_permissions_diff_.end() == it_pending) {
     LOG4CXX_WARN(
@@ -826,6 +1007,24 @@ void PolicyManagerImpl::CheckPendingPermissionsChanges(
   return;
 }
 
+void PolicyManagerImpl::NotifyPermissionsChanges(
+    const std::string& policy_app_id,
+    const std::vector<FunctionalGroupPermission>& app_group_permissions) {
+  // Get current functional groups from DB with RPC permissions
+  policy_table::FunctionalGroupings functional_groups;
+  cache_->GetFunctionalGroupings(functional_groups);
+
+  // Get list of groups assigned to application
+  policy_table::Strings app_groups = GetGroupsNames(app_group_permissions);
+
+  // Fill notification data according to group permissions
+  Permissions notification_data;
+  PrepareNotificationData(
+      functional_groups, app_groups, app_group_permissions, notification_data);
+
+  listener()->OnPermissionsUpdated(policy_app_id, notification_data);
+}
+
 void PolicyManagerImpl::SetUserConsentForApp(
     const PermissionConsent& permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -843,6 +1042,7 @@ void PolicyManagerImpl::SetUserConsentForApp(
   if (!cache_->SetUserPermissionsForApp(verified_permissions,
                                         &app_permissions_changed)) {
     LOG4CXX_WARN(logger_, "Can't set user permissions for application.");
+    return;
   }
 
   if (!app_permissions_changed) {
@@ -857,34 +1057,11 @@ void PolicyManagerImpl::SetUserConsentForApp(
                        verified_permissions.policy_app_id,
                        updated_app_group_permissons);
 
-  // Change pending permissions isConsentNeeded state, if no unconsented
-  // groups left
-  CheckPendingPermissionsChanges(permissions.policy_app_id,
+  CheckPendingPermissionsChanges(verified_permissions.policy_app_id,
                                  updated_app_group_permissons);
 
-  // Get current functional groups from DB with RPC permissions
-  policy_table::FunctionalGroupings functional_groups;
-  cache_->GetFunctionalGroupings(functional_groups);
-
-  // Get list of groups assigned to application
-  policy_table::Strings app_groups;
-  std::vector<FunctionalGroupPermission>::const_iterator it =
-      updated_app_group_permissons.begin();
-  std::vector<FunctionalGroupPermission>::const_iterator it_end =
-      updated_app_group_permissons.end();
-  for (; it != it_end; ++it) {
-    app_groups.push_back((*it).group_name);
-  }
-
-  // Fill notification data according to group permissions
-  Permissions notification_data;
-  PrepareNotificationData(functional_groups,
-                          app_groups,
-                          updated_app_group_permissons,
-                          notification_data);
-
-  listener()->OnPermissionsUpdated(verified_permissions.policy_app_id,
-                                   notification_data);
+  NotifyPermissionsChanges(verified_permissions.policy_app_id,
+                           updated_app_group_permissons);
 }
 
 bool PolicyManagerImpl::GetDefaultHmi(const std::string& policy_app_id,
@@ -998,6 +1175,13 @@ void PolicyManagerImpl::GetPermissionsForApp(
   LOG4CXX_AUTO_TRACE(logger_);
   std::string app_id_to_check = policy_app_id;
 
+  if (!cache_->IsApplicationRepresented(policy_app_id)) {
+    LOG4CXX_WARN(logger_,
+                 "Application with id " << policy_app_id
+                                        << " is not found within known apps.");
+    return;
+  }
+
   bool allowed_by_default = false;
   if (cache_->IsDefaultPolicy(policy_app_id)) {
     app_id_to_check = kDefaultId;
@@ -1136,115 +1320,6 @@ const PolicySettings& PolicyManagerImpl::get_settings() const {
   return *settings_;
 }
 
-void PolicyManagerImpl::UpdateAppConsentWithExternalConsent(
-    const std::string& device_id,
-    const std::string& application_id,
-    const GroupsNames& allowed_groups,
-    const GroupsNames& disallowed_groups) {
-  LOG4CXX_AUTO_TRACE(logger_);
-
-  if (allowed_groups.empty() && disallowed_groups.empty()) {
-    LOG4CXX_DEBUG(logger_,
-                  "Allowed and disallowed groups are empty, skipping update by "
-                  "external user consent.");
-    return;
-  }
-
-  std::vector<FunctionalGroupPermission> current_permissions;
-  GetUserConsentForApp(device_id, application_id, current_permissions);
-
-  std::vector<FunctionalGroupPermission> external_consent_groups_matches;
-  ConsentsUpdater updater(
-      allowed_groups, disallowed_groups, external_consent_groups_matches);
-  std::for_each(
-      current_permissions.begin(), current_permissions.end(), updater);
-
-  const std::string source = "GUI";
-
-  PermissionConsent updated_user_permissions;
-  updated_user_permissions.group_permissions = current_permissions;
-  updated_user_permissions.device_id = device_id;
-  updated_user_permissions.policy_app_id = application_id;
-  updated_user_permissions.consent_source = source;
-
-  // Need to check to which app to send notification since maybe app registered
-  // from different device
-  SetUserConsentForApp(updated_user_permissions);
-
-  PermissionConsent updated_external_consent_permissions;
-  updated_external_consent_permissions.group_permissions =
-      external_consent_groups_matches;
-  updated_external_consent_permissions.device_id = device_id;
-  updated_external_consent_permissions.policy_app_id = application_id;
-  updated_user_permissions.consent_source = source;
-
-  cache_->SetExternalConsentForApp(updated_external_consent_permissions);
-}
-
-void PolicyManagerImpl::NotifySystem(
-    const PolicyManagerImpl::AppPoliciesValueType& app_policy) const {
-  listener()->OnPendingPermissionChange(app_policy.first);
-}
-
-void PolicyManagerImpl::SendPermissionsToApp(
-    const PolicyManagerImpl::AppPoliciesValueType& app_policy) {
-  const std::string app_id = app_policy.first;
-
-  const std::string device_id = GetCurrentDeviceId(app_id);
-  if (device_id.empty()) {
-    LOG4CXX_WARN(logger_,
-                 "Couldn't find device info for application id: " << app_id);
-    return;
-  }
-  std::vector<FunctionalGroupPermission> group_permissons;
-  GetPermissionsForApp(device_id, app_id, group_permissons);
-
-  Permissions notification_data;
-
-  // Need to get rid of this call
-  utils::SharedPtr<policy_table::Table> policy_table_snapshot =
-      cache_->GenerateSnapshot();
-
-  PrepareNotificationData(
-      policy_table_snapshot->policy_table.functional_groupings,
-      app_policy.second.groups,
-      group_permissons,
-      notification_data);
-
-  LOG4CXX_INFO(logger_, "Send notification for application_id: " << app_id);
-  listener()->OnPermissionsUpdated(
-      app_id,
-      notification_data,
-      policy_table::EnumToJsonString(app_policy.second.default_hmi));
-}
-
-void PolicyManagerImpl::ProcessExternalConsentStatusUpdate(
-    const GroupsByExternalConsentStatus& groups_by_status) {
-  GroupsNames allowed_groups;
-  GroupsNames disallowed_groups;
-  CalculateGroupsConsentFromExternalConsent(
-      groups_by_status, allowed_groups, disallowed_groups);
-
-  std::map<std::string, std::string> known_links =
-      cache_->GetKnownLinksFromPT();
-  std::map<std::string, std::string> registered_links;
-  listener_->GetRegisteredLinks(registered_links);
-
-  std::map<std::string, std::string> all_known;
-  std::merge(known_links.begin(),
-             known_links.end(),
-             registered_links.begin(),
-             registered_links.end(),
-             std::inserter(all_known, all_known.begin()));
-
-  std::map<std::string, std::string>::const_iterator it_links =
-      all_known.begin();
-  for (; all_known.end() != it_links; ++it_links) {
-    UpdateAppConsentWithExternalConsent(
-        it_links->first, it_links->second, allowed_groups, disallowed_groups);
-  }
-}
-
 bool PolicyManagerImpl::SetExternalConsentStatus(
     const ExternalConsentStatus& status) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1434,9 +1509,11 @@ void PolicyManagerImpl::SetVINValue(const std::string& value) {
 
 AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
     const std::string& policy_app_id) {
-  typedef std::map<std::string, AppPermissions>::iterator PermissionsIt;
-  PermissionsIt app_id_diff = app_permissions_diff_.find(policy_app_id);
+  PendingPermissions::iterator app_id_diff =
+      app_permissions_diff_.find(policy_app_id);
+
   AppPermissions permissions(policy_app_id);
+
   if (app_permissions_diff_.end() != app_id_diff) {
     permissions = app_id_diff->second;
   } else {
@@ -1580,6 +1657,22 @@ bool PolicyManagerImpl::IsPredataPolicy(
   return cache_->IsPredataPolicy(policy_app_id);
 }
 
+void PolicyManagerImpl::ProcessCCSStatusForApp(
+    const std::string& application_id) {
+  CCSStatus status = cache_->GetCCSStatus();
+  GroupsByCCSStatus groups_by_status =
+      cache_->GetGroupsWithSameEntities(status);
+
+  GroupsNames allowed_groups;
+  GroupsNames disallowed_groups;
+  CalculateGroupsConsentFromCCS(
+      groups_by_status, allowed_groups, disallowed_groups);
+
+  const std::string device_id = GetCurrentDeviceId(application_id);
+  UpdateAppConsentWithCCS(
+      device_id, application_id, allowed_groups, disallowed_groups);
+}
+
 void PolicyManagerImpl::AddNewApplication(const std::string& application_id,
                                           DeviceConsent device_consent) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1598,6 +1691,8 @@ void PolicyManagerImpl::AddNewApplication(const std::string& application_id,
                      << " permissions for application id: " << application_id);
     cache_->SetDefaultPolicy(application_id);
   }
+
+  ProcessCCSStatusForApp(application_id);
 }
 
 void PolicyManagerImpl::PromoteExistedApplication(
@@ -1608,14 +1703,8 @@ void PolicyManagerImpl::PromoteExistedApplication(
       cache_->IsPredataPolicy(application_id)) {
     cache_->SetDefaultPolicy(application_id);
   }
-  if (HasCertificate()) {
-    LOG4CXX_DEBUG(logger_, "Certificate exits, no update required.");
-    return;
-  }
 
-  if (cache_->AppHasHMIType(application_id, policy_table::AHT_NAVIGATION)) {
-    update_status_manager_.ScheduleUpdate();
-  }
+  ProcessCCSStatusForApp(application_id);
 }
 
 bool PolicyManagerImpl::IsNewApplication(
diff --git a/src/components/policy/policy_external/src/policy_table/types.cc b/src/components/policy/policy_external/src/policy_table/types.cc
index 85448e2677..4d7d63ce51 100644
--- a/src/components/policy/policy_external/src/policy_table/types.cc
+++ b/src/components/policy/policy_external/src/policy_table/types.cc
@@ -2094,6 +2094,9 @@ bool ExternalConsentEntity::operator==(const ExternalConsentEntity& rhs) const {
 }
 
 bool ExternalConsentEntity::is_valid() const {
+  if (!is_initialized()) {
+    return false;
+  }
   if (!entity_type.is_valid()) {
     return false;
   }
diff --git a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
index edc2fa14a9..fd49464528 100644
--- a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
@@ -1768,42 +1768,8 @@ bool SQLPTExtRepresentation::SetVINValue(const std::string& value) {
   return result;
 }
 
-bool SQLPTExtRepresentation::RemoveAppConsentForGroup(
-    const std::string& policy_app_id,
-    const std::string& functional_group_name) const {
-  utils::dbms::SQLQuery query_group_id(db());
-  if (!query_group_id.Prepare(sql_pt_ext::kSelectGroupId)) {
-    LOG4CXX_WARN(logger_, "Incorect statement for select group name.");
-    return false;
-  }
-
-  query_group_id.Bind(0, functional_group_name);
-
-  if (!query_group_id.Exec()) {
-    LOG4CXX_WARN(logger_, "Failed to select group id.");
-    return false;
-  }
-
-  const int id = query_group_id.GetInteger(0);
-
-  utils::dbms::SQLQuery query(db());
-  if (!query.Prepare(sql_pt_ext::kDeleteAppGroupConsent)) {
-    LOG4CXX_WARN(logger_, "Incorect statement for remove app consent.");
-    return false;
-  }
-
-  query.Bind(0, policy_app_id);
-  query.Bind(1, id);
-
-  if (!query.Exec()) {
-    LOG4CXX_WARN(logger_, "Failed to remove app consent.");
-    return false;
-  }
-
-  return true;
-}
 
-bool SQLPTExtRepresentation::SaveExternalConsentStatus(
+bool SQLPTExtRepresentation::SetExternalConsentStatus(
     const ExternalConsentStatus& status) const {
   LOG4CXX_AUTO_TRACE(logger_);
   utils::dbms::SQLQuery query(db());
diff --git a/src/components/policy/policy_external/test/generated_code_test.cc b/src/components/policy/policy_external/test/generated_code_test.cc
index 2704f03c6a..f9bee95486 100644
--- a/src/components/policy/policy_external/test/generated_code_test.cc
+++ b/src/components/policy/policy_external/test/generated_code_test.cc
@@ -135,6 +135,96 @@ TEST(PolicyGeneratedCodeTest, IntegerConstructionAndAssignmentTest) {
   EXPECT_FALSE(valid_value.is_valid());
 }
 
+TEST(PolicyGeneratedCodeTest, TestConsentsGroup_Validation) {
+  using namespace rpc::policy_table_interface_base;
+  // Need to validate CCS consents container wrapped with Optional for case w/o
+  // specific values assigned since it is of generic 'Map' type which requires
+  // to be empty + initialized in order to be valid
+  // Also Map type does not have specific validation on PT type
+
+  rpc::Optional<ConsentGroups> consent_groups;
+
+  EXPECT_TRUE(consent_groups.is_valid());
+
+  consent_groups->insert(
+      std::make_pair(std::string("Group1"), rpc::Boolean(true)));
+
+  EXPECT_TRUE(consent_groups.is_valid());
+
+  // Adds more than container maximum size
+  for (size_t number = 0; number < 256; ++number) {
+    std::stringstream name;
+    name << "Group" << number;
+    consent_groups->insert(std::make_pair(name.str(), rpc::Boolean(true)));
+  }
+
+  EXPECT_FALSE(consent_groups.is_valid());
+}
+
+TEST(PolicyGeneratedCodeTest,
+     TestConsentRecords_ExternalConsents_PT_Validation) {
+  using namespace rpc::policy_table_interface_base;
+  ConsentRecords consent_records;
+
+  // PT_SNAPSHOT does not care of consents since their type is 'optional'
+  // PT_UPDATE and PT_SNAPSHOT have consents as 'omitted' so they must be absent
+  consent_records.SetPolicyTableType(PT_UPDATE);
+  EXPECT_TRUE(consent_records.is_valid());
+
+  consent_records.SetPolicyTableType(PT_PRELOADED);
+  EXPECT_TRUE(consent_records.is_valid());
+
+  consent_records.SetPolicyTableType(PT_SNAPSHOT);
+  EXPECT_TRUE(consent_records.is_valid());
+
+  consent_records.external_consent_status_groups->insert(
+      std::make_pair(std::string("Group1"), true));
+
+  consent_records.external_consent_status_groups->insert(
+      std::make_pair(std::string("Group2"), false));
+
+  consent_records.SetPolicyTableType(PT_UPDATE);
+  EXPECT_FALSE(consent_records.is_valid());
+
+  consent_records.SetPolicyTableType(PT_PRELOADED);
+  EXPECT_FALSE(consent_records.is_valid());
+
+  consent_records.SetPolicyTableType(PT_SNAPSHOT);
+  EXPECT_TRUE(consent_records.is_valid());
+}
+
+TEST(PolicyGeneratedCodeTest, CCSEntity_ConstructionValidationTest) {
+  using namespace rpc::policy_table_interface_base;
+
+  CCS_Entity empty_entity;
+  EXPECT_FALSE(empty_entity.is_valid());
+
+  const std::string corrent_entity_type_field = "entityType";
+  const std::string correct_entity_id_field = "entityID";
+
+  Json::Value correct_json_entity;
+  correct_json_entity[corrent_entity_type_field] = 1;
+  correct_json_entity[correct_entity_id_field] = 2;
+
+  ExternalConsent_Entity entity_from_correct_json(&correct_json_entity);
+  EXPECT_TRUE(entity_from_correct_json.is_valid());
+
+  const std::string wrong_entity_id_field = "entityId";
+
+  Json::Value wrong_json_entity;
+  wrong_json_entity[corrent_entity_type_field] = 1;
+  wrong_json_entity[wrong_entity_id_field] = 2;
+
+  ExternalConsent_Entity entity_from_wrong_json(&wrong_json_entity);
+  EXPECT_FALSE(entity_from_wrong_json.is_valid());
+
+  ExternalConsent_Entity entity_from_valid_ints(1, 2);
+  EXPECT_TRUE(entity_from_valid_ints.is_valid());
+
+  CCS_Entity entity_from_wrong_ints(129, 129);
+  EXPECT_FALSE(entity_from_wrong_ints.is_valid());
+}
+
 }  // namespace policy_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
index 0d2cc19db4..09a4a0e391 100644
--- a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
+++ b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
@@ -193,6 +193,35 @@ class PolicyManagerImplTest2 : public ::testing::Test {
 
   // Load Json File and set it as PTU
   void LoadPTUFromJsonFile(const std::string& update_file);
+
+  void EmulatePTAppRevoked(const std::string& ptu_name);
+
+  void TestSetDeviceUSBConnection(
+      const policy_table::UserSetting usb_transport_status);
+
+  void TestUpdateUSBConnectionStatus(
+      const policy_table::UserSetting usb_transport_status);
+
+  utils::SharedPtr<policy_table::Table> PreconditionForBasicValidateSnapshot();
+
+  template <typename ParentType, typename Value>
+  bool IsKeyExisted(const ParentType& parent, const Value& value) const {
+    return parent.end() != std::find(parent.begin(), parent.end(), value);
+  }
+
+  template <typename ParentType>
+  bool IsKeyExisted(const ParentType& parent, const std::string& value) const {
+    return parent.end() != parent.find(value);
+  }
+
+  template <typename ParentType, typename KeyType>
+  const KeyType& GetKeyData(const ParentType& parent,
+                            const std::string& key_name) const {
+    DCHECK(IsKeyExisted<ParentType>(parent, key_name));
+    return parent.find(key_name)->second;
+  }
+
+  bool CheckPolicyTimeStamp(const std::string& str) const;
 };
 
 class PolicyManagerImplTest_RequestTypes : public ::testing::Test {
@@ -238,6 +267,37 @@ class PolicyManagerImplTest_RequestTypes : public ::testing::Test {
   void TearDown() OVERRIDE;
 };
 
+class PolicyManagerImplTest_CCS : public PolicyManagerImplTest2 {
+ public:
+  PolicyManagerImplTest_CCS()
+      : PolicyManagerImplTest2()
+      , group_name_1_("Group1")
+      , group_name_2_("Group2")
+      , group_name_3_("Group3") {}
+
+ protected:
+  void PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  void PreconditionCCSPreparePTWithAppPolicy();
+
+  policy_table::Table PreparePTWithGroupsHavingCCS();
+
+  std::string PreparePTUWithNewGroup(const uint32_t type,
+                                     const uint32_t id,
+                                     const std::string& group_name);
+
+  const uint32_t type_1_ = 0;
+  const uint32_t id_1_ = 1;
+  const uint32_t type_2_ = 2;
+  const uint32_t id_2_ = 3;
+  const uint32_t type_3_ = 4;
+  const uint32_t id_3_ = 5;
+
+  const std::string group_name_1_;
+  const std::string group_name_2_;
+  const std::string group_name_3_;
+};
+
 }  // namespace policy_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
index 5983f3c7c8..504467d229 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
@@ -85,6 +85,7 @@ TEST_F(PolicyManagerImplTest,
 
 TEST_F(PolicyManagerImplTest2, GetNotificationsNumberAfterPTUpdate) {
   // Arrange
+  CreateLocalPT(preloaded_pt_filename_);
 
   Json::Value table = createPTforLoad();
   policy_manager_->ForcePTExchange();
@@ -125,7 +126,12 @@ TEST_F(PolicyManagerImplTest2, GetNotificationsNumberAfterPTUpdate) {
 
 TEST_F(PolicyManagerImplTest2, IsAppRevoked_SetRevokedAppID_ExpectAppRevoked) {
   // Arrange
-  std::ifstream ifile(kValidSdlPtUpdateJson);
+  CreateLocalPT(preloaded_pt_filename_);
+
+  AppHmiTypes types;
+  policy_manager_->AddApplication(app_id_1_, types);
+
+  std::ifstream ifile(preloaded_pt_filename_);
   Json::Reader reader;
   std::string json;
   Json::Value root(Json::objectValue);
@@ -138,41 +144,38 @@ TEST_F(PolicyManagerImplTest2, IsAppRevoked_SetRevokedAppID_ExpectAppRevoked) {
   ::policy::BinaryMessage msg(json.begin(), json.end());
   ASSERT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+  CheckRpcPermissions(
+      app_id_1_, "UnregisterAppInterface", ::policy::kRpcDisallowed);
   EXPECT_TRUE(policy_manager_->IsApplicationRevoked(app_id_1_));
 }
 
-TEST_F(
-    PolicyManagerImplTest2,
-    IsAppRevoked_ReregisterRevokedApp_OnHmiNotificationIsSentWithProperValues) {
+// Related to manual test APPLINK-18792
+TEST_F(PolicyManagerImplTest2, AppRevokedOne_AppRegistered) {
   // Arrange
-  CreateLocalPT(preloadet_pt_filename_);
-
-  manager_->AddApplication(app_id_1_);
+  CreateLocalPT(preloaded_pt_filename_);
+  EmulatePTAppRevoked(kPtu2Json);
 
-  // Check RPC is allowed and OnHMIStatus is sent
-  CheckRpcPermissions("OnHMIStatus", ::policy::kRpcAllowed);
-
-  std::ifstream ifile(kValidSdlPtUpdateJson);
-  Json::Reader reader;
-  std::string json;
-  Json::Value root(Json::objectValue);
-  if (ifile.is_open() && reader.parse(ifile, root, true)) {
-    root["policy_table"]["app_policies"][app_id_1_] = Json::nullValue;
-    json = root.toStyledString();
-  }
-  ifile.close();
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  policy_manager_->AddApplication(application_id_, hmi_types_);
+  // Registration is allowed
+  CheckRpcPermissions("RegisterAppInterface", ::policy::kRpcAllowed);
+}
 
-  ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
-  EXPECT_TRUE(manager_->IsApplicationRevoked(app_id_1_));
+// Related to manual test APPLINK-18794
+TEST_F(PolicyManagerImplTest2, AppRevokedOne_AppRegistered_HMIDefault) {
+  // Arrange
+  CreateLocalPT(preloaded_pt_filename_);
+  EmulatePTAppRevoked(kPtu2Json);
 
-  // Re-register application
-  manager_->AddApplication(app_id_1_);
-  EXPECT_NE(typeid(utils::CallNothing),
-            typeid(manager_->AddApplication(app_id_1_)));
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+  policy_manager_->AddApplication(application_id_, hmi_types_);
 
-  // Check RPC is disallowed and OnHMIStatus is sent
-  CheckRpcPermissions("OnHMIStatus", ::policy::kRpcDisallowed);
+  std::string default_hmi;
+  // Default HMI level is NONE
+  EXPECT_TRUE(policy_manager_->GetDefaultHmi(application_id_, &default_hmi));
+  EXPECT_EQ("NONE", default_hmi);
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -546,6 +549,34 @@ TEST_F(PolicyManagerImplTest2,
   EXPECT_TRUE(output.list_of_undefined_params.empty());
 }
 
+TEST_F(PolicyManagerImplTest2, GetUpdateUrl) {
+  // Arrange
+  CreateLocalPT(preloaded_pt_filename_);
+  GetPTU(preloaded_pt_filename_);
+  // Check expectations
+  const std::string update_url(
+      "http://policies.telematics.ford.com/api/policies");
+  EXPECT_EQ(update_url, policy_manager_->GetUpdateUrl(7));
+  EXPECT_EQ("", policy_manager_->GetUpdateUrl(4));
+}
+
+// Related to manual test APPLINK-18789
+TEST_F(PolicyManagerImplTest2, GetCorrectStatus_PTUSuccessful) {
+  // Precondition
+  CreateLocalPT(preloaded_pt_filename_);
+  // Check
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
+
+  // Adding changes PT status
+  policy_manager_->AddApplication(application_id_, hmi_types_);
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
+  // Before load PT we should send notification about start updating
+  policy_manager_->OnUpdateStarted();
+  // Update
+  GetPTU(kPtu3Json);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
+}
+
 TEST_F(PolicyManagerImplTest2,
        CheckPermissions_NoParamsInPT_AddAppWithAllParams_CheckRpcsInDiffLvls) {
   // File does not have parameters, so they all are permitted
@@ -1587,14 +1618,16 @@ TEST_F(
   policy_table::RequestTypes correct_types;
   correct_types.push_back(policy_table::RequestType::RT_HTTP);
 
-  // Load RequestType with invalid values
-  RefreshPT(preloadet_pt_filename_, kJsonFiles[13]);
+  ON_CALL(listener_, OnCurrentDeviceIdUpdateRequired(_))
+      .WillByDefault(Return(device_id));
+
+  utils::SharedPtr<Table> pt = (policy_manager_->GetCache())->GetPT();
 
   // Get Request Types for "<pre_DataConsent>"
   policy_table::RequestTypes received_types =
       GetRequestTypesForApplication(policy::kPreDataConsentId);
 
-  CompareRequestTypesContainers(correct_types, received_types);
+  const DeviceData& device_data = *pt->policy_table.device_data;
 }
 
 TEST_F(PolicyManagerImplTest_RequestTypes,
@@ -1602,13 +1635,25 @@ TEST_F(PolicyManagerImplTest_RequestTypes,
   // Load RequestType with empty values
   RefreshPT(preloadet_pt_filename_, kJsonFiles[14]);
 
-  // Get Request Types for "<pre_DataConsent>"
-  policy_table::RequestTypes received_types =
-      GetRequestTypesForApplication(policy::kPreDataConsentId);
+  EXPECT_EQ(1u, device_data.size());
 
-  // Expect
-  const size_t received_size = received_types.size();
-  EXPECT_EQ(0u, received_size);
+  const DeviceData::const_iterator dev_data_iter = device_data.find(device_id);
+  EXPECT_TRUE(device_data.end() != dev_data_iter);
+
+  UserConsentRecords::const_iterator it_device_consent =
+      dev_data_iter->second.user_consent_records->find(device);
+
+  EXPECT_TRUE(dev_data_iter->second.user_consent_records->end() !=
+              it_device_consent);
+
+  const ConsentRecords& parameters = it_device_consent->second;
+  const Json::Value time_stamp = (parameters.time_stamp).ToJsonValue();
+  EXPECT_EQ(device, it_device_consent->first);
+
+  const bool time_stamp_result = CheckPolicyTimeStamp(time_stamp.asString());
+
+  EXPECT_TRUE(time_stamp_result);
+  EXPECT_EQ(DeviceConsent::kDeviceAllowed, device_consent);
 }
 
 TEST_F(
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
index 6a10478399..050630514c 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
@@ -259,19 +259,19 @@ TEST_F(PolicyManagerImplTest2,
 TEST_F(
     PolicyManagerImplTest2,
     AddValidRequestTypeToPT_GetNewAppWithSpecificPoliciesViaPTU_ExpectRTAdded) {
-  const std::string section_name = application_id_;
+  const std::string& app_id = application_id_;
 
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Add app
-  policy_manager_->AddApplication(section_name);
+  policy_manager_->AddApplication(app_id, hmi_types_);
   // Check app gets RequestTypes from pre_DataConsent of app_policies
   // section
-  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(app_id);
 
   // Only single item as in pre_DataConsent in preloaded PT
   EXPECT_EQ(1u, pt_request_types_.size());
-  EXPECT_CALL(listener_, OnPendingPermissionChange(section_name)).Times(1);
+  EXPECT_CALL(listener_, OnPendingPermissionChange(app_id)).Times(1);
 
   // PTU has RequestTypes as [] - means 'all allowed'
   Json::Value root = GetPTU("json/PTU2.json");
@@ -284,18 +284,18 @@ TEST_F(
 
   // Get App Request Types from PTU
   ptu_request_types_ =
-      root["policy_table"]["app_policies"][section_name]["RequestType"];
+      root["policy_table"]["app_policies"][app_id]["RequestType"];
   ptu_request_types_size_ = ptu_request_types_.size();
 
   pt_request_types_.clear();
   // Get RequestTypes from <app_id> section of app policies after PT update
-  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(app_id);
 
   // Check sizes of Request types of PT and PTU
   ASSERT_EQ(ptu_request_types_size_, pt_request_types_.size());
 
   ::policy::AppPermissions permissions =
-      policy_manager_->GetAppPermissionsChanges(section_name);
+      policy_manager_->GetAppPermissionsChanges(app_id);
   EXPECT_TRUE(permissions.requestTypeChanged);
 
   ::policy::StringArray result;
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_test.cc
index 77a70f1b45..d260e16922 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_test.cc
@@ -34,9 +34,11 @@
 
 #include "json/reader.h"
 #include "gtest/gtest.h"
+#include <utility>
 
 #include "policy/policy_manager_impl_test_base.h"
 #include "utils/make_shared.h"
+#include "utils/shared_ptr.h"
 
 using ::testing::_;
 using ::testing::Return;
@@ -341,6 +343,746 @@ TEST_F(PolicyManagerImplTest2, GetCurrentDeviceId) {
   EXPECT_EQ("", policy_manager_->GetCurrentDeviceId(app_id_2_));
 }
 
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusWhileAppExists_ExpectUserConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  // Checking groups consents before setting CCS status
+  const policy_table::DeviceData::const_iterator device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != device_data);
+
+  const UserConsentRecords::const_iterator updated_consent_records =
+      device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  const ConsentGroups::const_iterator group_1 =
+      updated_consent_records->second.consent_groups->find(group_name_1_);
+  EXPECT_TRUE(updated_consent_records->second.consent_groups->end() != group_1);
+
+  EXPECT_EQ(Boolean(true), group_1->second);
+
+  const ConsentGroups::const_iterator group_2 =
+      updated_consent_records->second.consent_groups->find(group_name_2_);
+
+  EXPECT_TRUE(updated_consent_records->second.consent_groups->end() != group_2);
+
+  EXPECT_EQ(Boolean(false), group_2->second);
+
+  const ConsentGroups::const_iterator group_3 =
+      updated_consent_records->second.consent_groups->find(group_name_3_);
+
+  EXPECT_FALSE(updated_consent_records->second.consent_groups->end() !=
+               group_3);
+
+  // Act - setting new CCS status
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking groups consent after setting CCS status
+  EXPECT_EQ(Boolean(false), group_1->second);
+  EXPECT_EQ(Boolean(true), group_2->second);
+
+  // Check, that no consent has been added for third groups
+  const ConsentGroups::const_iterator updated_group_3 =
+      updated_consent_records->second.consent_groups->find(group_name_3_);
+
+  EXPECT_FALSE(updated_consent_records->second.consent_groups->end() !=
+               updated_group_3);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusWhileAppExists_ExpectCCSConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  // Checking CCS consents before setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  EXPECT_TRUE(updated_consent_records->second.ccs_consent_groups->empty());
+
+  // Act - setting new CCS status
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking CCS consents after setting new CCS status
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.ccs_consent_groups;
+
+  const ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  const ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  const ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusNewAppAddedAfterward_ExpectCCSConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppPolicy();
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking CCS consents after setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_FALSE(pt->policy_table.device_data->end() != updated_device_data);
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillRepeatedly(Return(device_id_1_));
+
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Check CCS consents for application
+  updated_device_data = pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.ccs_consent_groups;
+
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusNewAppAddedAfterward_ExpectUserConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppPolicy();
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking CCS consents after setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_FALSE(pt->policy_table.device_data->end() != updated_device_data);
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillRepeatedly(Return(device_id_1_));
+
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Checking CCS consents after setting new CCS status
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  updated_device_data = pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.consent_groups;
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusNewAppPromotedAfterward_ExpectUserConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  CreateLocalPT(preloaded_pt_filename_);
+  Table t = PreparePTWithGroupsHavingCCS();
+
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _)).Times(AtLeast(2));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillOnce(Return(device_id_1_))         // registered
+      .WillOnce(Return(""))                   // not registered
+      .WillRepeatedly(Return(device_id_1_));  // again registered
+
+  // First register w/o app having groups to consent
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking CCS consents after setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_FALSE(pt->policy_table.device_data->end() != updated_device_data);
+
+  ApplicationParams app_params;
+  app_params.groups.push_back(group_name_1_);
+  app_params.groups.push_back(group_name_2_);
+
+  t.policy_table.app_policies_section.apps.insert(
+      std::make_pair(app_id_1_, app_params));
+
+  // Adding application groups to consent, will be pending untill next
+  // registration
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+
+  // Second time register w/ app having groups to consent
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Checking CCS consents after setting new CCS status
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  updated_device_data = pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.consent_groups;
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusNewAppPromotedAfterward_ExpectCCSConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  CreateLocalPT(preloaded_pt_filename_);
+  Table t = PreparePTWithGroupsHavingCCS();
+
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _)).Times(AtLeast(2));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillOnce(Return(device_id_1_))         // registered
+      .WillOnce(Return(""))                   // not registered
+      .WillRepeatedly(Return(device_id_1_));  // registered again
+
+  // First register w/o app having groups to consent
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  // Checking CCS consents after setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_FALSE(pt->policy_table.device_data->end() != updated_device_data);
+
+  ApplicationParams app_params;
+  app_params.groups.push_back(group_name_1_);
+  app_params.groups.push_back(group_name_2_);
+
+  t.policy_table.app_policies_section.apps.insert(
+      std::make_pair(app_id_1_, app_params));
+
+  // Adding application groups to consent, will be pending i.e. not consented
+  // yet, untill next registration
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+
+  // Second time register w/ app having groups to consent
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  // Check CCS consents for application
+  updated_device_data = pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.ccs_consent_groups;
+
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_PTUWithNewGroups_ExpectCCSConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  const uint32_t type_4 = 6u;
+  const uint32_t id_4 = 7u;
+  const std::string group_name_4 = "NewGroup";
+
+  // CCS status has new group, which is not yet assigned to any application
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_4, id_4, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _)).Times(AtLeast(1));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillRepeatedly(Return(device_id_1_));
+
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  // Check CCS consents for application
+  policy_table::DeviceData::const_iterator initial_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != initial_device_data);
+
+  UserConsentRecords::const_iterator initial_consent_records =
+      initial_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(initial_device_data->second.user_consent_records->end() !=
+              initial_consent_records);
+
+  const ConsentGroups& ccs_consents =
+      *initial_consent_records->second.ccs_consent_groups;
+
+  ConsentGroups::const_iterator group_1 = ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != group_1);
+
+  ConsentGroups::const_iterator group_2 = ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != group_2);
+
+  ConsentGroups::const_iterator group_4 = ccs_consents.find(group_name_4);
+
+  EXPECT_FALSE(ccs_consents.end() != group_4);
+
+  // Consents for known groups have been done
+  EXPECT_EQ(Boolean(false), group_1->second);
+  EXPECT_EQ(Boolean(true), group_2->second);
+
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  const std::string ptu_json =
+      PreparePTUWithNewGroup(type_4, id_4, group_name_4);
+
+  const BinaryMessage msg(ptu_json.begin(), ptu_json.end());
+
+  ON_CALL(listener_, GetRegisteredLinks())
+      .WillByDefault(Return(policy::ApplicationsLinks()));
+
+  EXPECT_CALL(listener_, OnCertificateUpdated(_));
+
+  EXPECT_TRUE(policy_manager_->LoadPT("DummyFileName", msg));
+
+  pt = policy_manager_->GetCache()->GetPT();
+
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  const ConsentGroups& updated_ccs_consents =
+      *updated_consent_records->second.ccs_consent_groups;
+
+  group_1 = updated_ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(updated_ccs_consents.end() != group_1);
+
+  group_2 = updated_ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(updated_ccs_consents.end() != group_2);
+
+  group_4 = updated_ccs_consents.find(group_name_4);
+
+  EXPECT_TRUE(updated_ccs_consents.end() != group_4);
+
+  EXPECT_EQ(Boolean(false), group_1->second);
+  EXPECT_EQ(Boolean(true), group_2->second);
+  EXPECT_EQ(Boolean(false), group_4->second);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_PTUWithNewGroups_ExpectUserConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  const uint32_t type_4 = 6u;
+  const uint32_t id_4 = 7u;
+  const std::string group_name_4 = "NewGroup";
+
+  CCSStatus status;
+  status.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status.insert(CCSStatusItem(type_4, id_4, kStatusOn));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _)).Times(AtLeast(1));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
+      .WillRepeatedly(Return(device_id_1_));
+
+  policy_manager_->AddApplication(app_id_1_, AppHmiTypes());
+
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  // Check CCS consents for application
+  policy_table::DeviceData::const_iterator initial_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != initial_device_data);
+
+  UserConsentRecords::const_iterator initial_consent_records =
+      initial_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(initial_device_data->second.user_consent_records->end() !=
+              initial_consent_records);
+
+  const ConsentGroups& user_consents =
+      *initial_consent_records->second.consent_groups;
+
+  ConsentGroups::const_iterator group_1 = user_consents.find(group_name_1_);
+
+  EXPECT_TRUE(user_consents.end() != group_1);
+
+  ConsentGroups::const_iterator group_2 = user_consents.find(group_name_2_);
+
+  EXPECT_TRUE(user_consents.end() != group_2);
+
+  ConsentGroups::const_iterator group_4 = user_consents.find(group_name_4);
+
+  EXPECT_FALSE(user_consents.end() != group_4);
+
+  EXPECT_EQ(Boolean(false), group_1->second);
+  EXPECT_EQ(Boolean(true), group_2->second);
+
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), user_consents.size());
+
+  const std::string ptu_json =
+      PreparePTUWithNewGroup(type_4, id_4, group_name_4);
+
+  const BinaryMessage msg(ptu_json.begin(), ptu_json.end());
+
+  ON_CALL(listener_, GetRegisteredLinks())
+      .WillByDefault(Return(policy::ApplicationsLinks()));
+
+  EXPECT_CALL(listener_, OnCertificateUpdated(_));
+
+  EXPECT_TRUE(policy_manager_->LoadPT("DummyFileName", msg));
+
+  pt = policy_manager_->GetCache()->GetPT();
+
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  const ConsentGroups& updated_user_consents =
+      *updated_consent_records->second.consent_groups;
+
+  group_1 = updated_user_consents.find(group_name_1_);
+
+  EXPECT_TRUE(updated_user_consents.end() != group_1);
+
+  group_2 = updated_user_consents.find(group_name_2_);
+
+  EXPECT_TRUE(updated_user_consents.end() != group_2);
+
+  group_4 = updated_user_consents.find(group_name_4);
+
+  EXPECT_TRUE(updated_user_consents.end() != group_4);
+
+  EXPECT_EQ(Boolean(false), group_1->second);
+  EXPECT_EQ(Boolean(true), group_2->second);
+  EXPECT_EQ(Boolean(false), group_4->second);
+
+  app_parameters = pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), user_consents.size());
+}
+
+TEST_F(PolicyManagerImplTest_CCS,
+       CCS_SetCCSStatusTurnOnThanOff_ExpectCCSConsentsUpdateForApp) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  PreconditionCCSPreparePTWithAppGroupsAndConsents();
+
+  // Act
+  utils::SharedPtr<policy_table::Table> pt =
+      policy_manager_->GetCache()->GetPT();
+
+  // Checking CCS consents before setting new CCS status
+  policy_table::DeviceData::const_iterator updated_device_data =
+      pt->policy_table.device_data->find(device_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.device_data->end() != updated_device_data);
+
+  UserConsentRecords::const_iterator updated_consent_records =
+      updated_device_data->second.user_consent_records->find(app_id_1_);
+
+  EXPECT_TRUE(updated_device_data->second.user_consent_records->end() !=
+              updated_consent_records);
+
+  EXPECT_TRUE(updated_consent_records->second.ccs_consent_groups->empty());
+
+  // Act - setting new CCS status
+  CCSStatus status_on;
+  status_on.insert(CCSStatusItem(type_1_, id_1_, kStatusOn));
+  status_on.insert(CCSStatusItem(type_2_, id_2_, kStatusOn));
+  status_on.insert(CCSStatusItem(type_3_, id_3_, kStatusOn));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status_on));
+
+  // Checking CCS consents after setting new CCS status
+  const ConsentGroups& ccs_consents =
+      *updated_consent_records->second.ccs_consent_groups;
+
+  ApplicationPolicies::const_iterator app_parameters =
+      pt->policy_table.app_policies_section.apps.find(app_id_1_);
+
+  EXPECT_TRUE(pt->policy_table.app_policies_section.apps.end() !=
+              app_parameters);
+
+  EXPECT_EQ(app_parameters->second.groups.size(), ccs_consents.size());
+
+  ConsentGroups::const_iterator updated_group_1 =
+      ccs_consents.find(group_name_1_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_1);
+
+  ConsentGroups::const_iterator updated_group_2 =
+      ccs_consents.find(group_name_2_);
+
+  EXPECT_TRUE(ccs_consents.end() != updated_group_2);
+
+  EXPECT_EQ(Boolean(false), updated_group_1->second);
+  EXPECT_EQ(Boolean(true), updated_group_2->second);
+
+  // Switching CCS status off
+  CCSStatus status_off;
+  status_off.insert(CCSStatusItem(type_1_, id_1_, kStatusOff));
+  status_off.insert(CCSStatusItem(type_2_, id_2_, kStatusOff));
+  status_off.insert(CCSStatusItem(type_3_, id_3_, kStatusOff));
+
+  EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_1_, _));
+
+  EXPECT_TRUE(policy_manager_->SetCCSStatus(status_on));
+
+  EXPECT_EQ(Boolean(true), updated_group_1->second);
+  EXPECT_EQ(Boolean(false), updated_group_2->second);
+}
+
 }  // namespace policy
 }  // namespace components
 }  // namespace test
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
index 30007babad..a2b2d14cb3 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
@@ -39,6 +39,7 @@
 
 #include "utils/file_system.h"
 #include "utils/make_shared.h"
+#include "utils/gen_hash.h"
 #include "json/reader.h"
 
 #include "policy/mock_pt_ext_representation.h"
@@ -50,6 +51,7 @@ namespace policy_test {
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::ContainerEq;
+using ::testing::_;
 
 // Help functions
 char GenRandomChar(char range_from, char range_to) {
@@ -199,8 +201,16 @@ PolicyManagerImplTest::PolicyManagerImplTest()
 void PolicyManagerImplTest::SetUp() {
   policy_manager_ = new PolicyManagerImpl();
   cache_manager_ = new MockCacheManagerInterface();
-  policy_manager_->set_cache_manager(cache_manager_);
-  policy_manager_->set_listener(&listener_);
+  manager_->set_cache_manager(cache_manager_);
+  manager_->set_listener(&listener_);
+
+  ON_CALL(*cache_manager_, GetCCSStatus()).WillByDefault(Return(CCSStatus()));
+  ON_CALL(*cache_manager_, GetGroupsWithSameEntities(_))
+      .WillByDefault(Return(GroupsByCCSStatus()));
+  ON_CALL(*cache_manager_, GetKnownLinksFromPT())
+      .WillByDefault(Return(ApplicationsLinks()));
+  ON_CALL(listener_, GetRegisteredLinks())
+      .WillByDefault(Return(policy::ApplicationsLinks()));
 }
 
 void PolicyManagerImplTest::TearDown() {
@@ -235,6 +245,9 @@ PolicyManagerImplTest2::PolicyManagerImplTest2()
     , ptu_request_types_(Json::arrayValue) {}
 
 void PolicyManagerImplTest2::SetUp() {
+  ON_CALL(listener_, GetRegisteredLinks())
+      .WillByDefault(Return(policy::ApplicationsLinks()));
+
   file_system::CreateDirectory(app_storage_folder_);
 
   policy_manager_ = new PolicyManagerImpl(in_memory_);
@@ -586,6 +599,9 @@ PolicyManagerImplTest_RequestTypes::PolicyManagerImplTest_RequestTypes()
     , preloadet_pt_filename_(kSdlPreloadedPtJson) {}
 
 void PolicyManagerImplTest_RequestTypes::SetUp() {
+  ON_CALL(listener_, GetRegisteredLinks())
+      .WillByDefault(Return(policy::ApplicationsLinks()));
+
   file_system::CreateDirectory(app_storage_folder_);
   const bool in_memory = true;
   policy_manager_impl_sptr_ = utils::MakeShared<PolicyManagerImpl>(in_memory);
@@ -705,6 +721,157 @@ void PolicyManagerImplTest_RequestTypes::TearDown() {
   file_system::RemoveDirectory(app_storage_folder_, true);
 }
 
+void PolicyManagerImplTest_CCS::
+    PreconditionCCSPreparePTWithAppGroupsAndConsents() {
+  using namespace policy_table;
+  using namespace rpc;
+
+  CreateLocalPT(preloaded_pt_filename_);
+  Table t = PreparePTWithGroupsHavingCCS();
+
+  ApplicationParams app_params;
+  app_params.groups.push_back(group_name_1_);
+  app_params.groups.push_back(group_name_2_);
+
+  t.policy_table.app_policies_section.apps.insert(
+      std::make_pair(app_id_1_, app_params));
+
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+
+  // User allows first group and disallows second group. Third is kept
+  // untouched.
+  PermissionConsent permissions;
+  permissions.device_id = device_id_1_;
+  permissions.policy_app_id = app_id_1_;
+
+  FunctionalGroupPermission group_permissions_1;
+  group_permissions_1.group_name = group_name_1_;
+  group_permissions_1.group_alias = group_name_1_;
+  group_permissions_1.group_id = utils::Djb2HashFromString(group_name_1_);
+  group_permissions_1.state = kGroupAllowed;
+
+  FunctionalGroupPermission group_permissions_2;
+  group_permissions_2.group_name = group_name_2_;
+  group_permissions_2.group_alias = group_name_2_;
+  group_permissions_2.group_id = utils::Djb2HashFromString(group_name_2_);
+  group_permissions_2.state = kGroupDisallowed;
+
+  permissions.group_permissions.push_back(group_permissions_1);
+  permissions.group_permissions.push_back(group_permissions_2);
+
+  policy_manager_->SetUserConsentForApp(permissions);
+}
+
+void PolicyManagerImplTest_CCS::PreconditionCCSPreparePTWithAppPolicy() {
+  using namespace policy_table;
+  using namespace rpc;
+
+  // PT has 3 functional groups with some entities in
+  // disallowed_by_ccs_entities_on/off. Groups consents can be changed.
+  CreateLocalPT(preloaded_pt_filename_);
+  Table t = PreparePTWithGroupsHavingCCS();
+
+  ApplicationParams app_params;
+  app_params.groups.push_back(group_name_1_);
+  app_params.groups.push_back(group_name_2_);
+
+  t.policy_table.app_policies_section.apps.insert(
+      std::make_pair(app_id_1_, app_params));
+
+  EXPECT_TRUE(policy_manager_->GetCache()->ApplyUpdate(t));
+}
+
+rpc::policy_table_interface_base::Table
+PolicyManagerImplTest_CCS::PreparePTWithGroupsHavingCCS() {
+  using namespace policy_table;
+  using namespace rpc;
+
+  // PT has 3 functional groups with some entities in
+  // disallowed_by_ccs_entities_on/off. Groups consents can be changed.
+
+  CCS_Entity entity_1(type_1_, id_1_);
+  CCS_Entity entity_2(type_2_, id_2_);
+  CCS_Entity entity_3(type_3_, id_3_);
+
+  Rpcs rpcs_1;
+  rpcs_1.disallowed_by_ccs_entities_on->push_back(entity_1);
+  *rpcs_1.user_consent_prompt = group_name_1_;
+  rpcs_1.rpcs.set_to_null();
+
+  Rpcs rpcs_2;
+  rpcs_2.disallowed_by_ccs_entities_off->push_back(entity_2);
+  *rpcs_2.user_consent_prompt = group_name_2_;
+  rpcs_2.rpcs.set_to_null();
+
+  Rpcs rpcs_3;
+  rpcs_3.disallowed_by_ccs_entities_on->push_back(entity_3);
+  *rpcs_3.user_consent_prompt = group_name_3_;
+  rpcs_3.rpcs.set_to_null();
+
+  Table t;
+  t.policy_table.functional_groupings.insert(
+      std::make_pair(group_name_1_, rpcs_1));
+  t.policy_table.functional_groupings.insert(
+      std::make_pair(group_name_2_, rpcs_2));
+  t.policy_table.functional_groupings.insert(
+      std::make_pair(group_name_3_, rpcs_3));
+
+  return t;
+}
+
+std::string PolicyManagerImplTest_CCS::PreparePTUWithNewGroup(
+    const uint32_t type, const uint32_t id, const std::string& group_name) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  std::ifstream ifile(preloaded_pt_filename_);
+  Json::Reader reader;
+  std::string json;
+  Json::Value root(Json::objectValue);
+  if (ifile.is_open() && reader.parse(ifile, root, true)) {
+    Table t = PreparePTWithGroupsHavingCCS();
+
+    CCS_Entity entity_4(type, id);
+
+    Rpcs rpcs_4;
+    rpcs_4.disallowed_by_ccs_entities_on->push_back(entity_4);
+    *rpcs_4.user_consent_prompt = group_name;
+    rpcs_4.rpcs.set_to_null();
+
+    t.policy_table.functional_groupings.insert(
+        std::make_pair(group_name, rpcs_4));
+
+    ApplicationParams app_params;
+    app_params.groups.push_back(group_name_1_);
+    app_params.groups.push_back(group_name_2_);
+    app_params.groups.push_back(group_name);
+    app_params.keep_context = Boolean(true);
+    app_params.steal_focus = Boolean(true);
+    app_params.default_hmi = HL_FULL;
+    app_params.priority = P_EMERGENCY;
+
+    t.policy_table.app_policies_section.apps.insert(
+        std::make_pair(app_id_1_, app_params));
+
+    const Json::Value overriden_table = t.ToJsonValue();
+
+    const std::string policy_table_key = "policy_table";
+    const std::string functional_groupings_key = "functional_groupings";
+    const std::string app_policies_key = "app_policies";
+
+    root[policy_table_key][functional_groupings_key] =
+        overriden_table[policy_table_key][functional_groupings_key];
+
+    root[policy_table_key][app_policies_key][app_id_1_] =
+        overriden_table[policy_table_key][app_policies_key][app_id_1_];
+
+    json = root.toStyledString();
+  }
+  ifile.close();
+
+  return json;
+}
+
 }  // namespace policy_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/policy/policy_external/test/sql_pt_ext_representation_test.cc b/src/components/policy/policy_external/test/sql_pt_ext_representation_test.cc
index 231da9fcac..8d5c980ccd 100644
--- a/src/components/policy/policy_external/test/sql_pt_ext_representation_test.cc
+++ b/src/components/policy/policy_external/test/sql_pt_ext_representation_test.cc
@@ -1399,7 +1399,238 @@ TEST_F(SQLPTExtRepresentationTest,
       "1, 64, 10) ";
   ASSERT_TRUE(query_wrapper_->Exec(query_insert_app));
   // Check
-  EXPECT_TRUE(reps->IsPredataPolicy("12345"));
+  EXPECT_TRUE(reps_->IsPredataPolicy("12345"));
+}
+
+TEST_F(SQLPTExtRepresentationTest, SaveUserConsentRecords_ExpectedSaved) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  const std::string device_id = "test_device_id";
+  const std::string app_id = "test_app_id";
+  const std::string ccs_group = "CCSGroup";
+  const std::string consent_group = "ConsentGroup";
+  const std::string time_stamp = "2016-08-29T17:12:07Z";
+  const Input input = Input::I_GUI;
+
+  Table original_table;
+  UserConsentRecords& user_consent_records =
+      *(*original_table.policy_table.device_data)[device_id]
+           .user_consent_records;
+
+  UserConsentRecords::mapped_type& app_records = user_consent_records[app_id];
+
+  app_records.ccs_consent_groups->insert(
+      std::make_pair(ccs_group, Boolean(true)));
+
+  app_records.consent_groups->insert(
+      std::make_pair(consent_group, Boolean(true)));
+
+  *app_records.input = input;
+  *app_records.time_stamp = time_stamp;
+
+  // Act
+  EXPECT_TRUE(reps_->Save(original_table));
+  utils::SharedPtr<Table> loaded_table = reps_->GenerateSnapshot();
+
+  // GetData/GetKeyData methods do internal existence check - no need to do it
+  // separately. In case of data is missing expectations will be violated.
+  DeviceData device_data = GetData<Table, DeviceData>(*loaded_table);
+
+  policy_table::DeviceParams device_parameters =
+      GetKeyData<DeviceData, policy_table::DeviceParams>(device_data,
+                                                         device_id);
+
+  ConsentRecords consents = GetKeyData<UserConsentRecords, ConsentRecords>(
+      *device_parameters.user_consent_records, app_id);
+
+  EXPECT_TRUE(
+      (IsKeyExist<ConsentGroups>(*consents.consent_groups, consent_group)));
+  EXPECT_TRUE(
+      (IsKeyExist<ConsentGroups>(*consents.ccs_consent_groups, ccs_group)));
+  EXPECT_EQ((String<1, 255>(time_stamp)), *consents.time_stamp);
+  EXPECT_EQ(input, *consents.input);
+}
+
+TEST_F(SQLPTExtRepresentationTest, SaveFunctionalGroupings_ExpectedSaved) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  const std::string group_name = "GroupName";
+  const std::string another_group_name = "AnotherGroup";
+  const std::string rpc_name = "RpcName";
+  const std::string user_consent_prompt = "TestConsentPrompt";
+  const std::string another_user_consent_prompt = "AnotherTestConsentPrompt";
+  CCS_Entity off_entity_1(0, 0);
+  CCS_Entity off_entity_2(0, 1);
+  CCS_Entity on_entity_1(1, 0);
+  CCS_Entity on_entity_2(1, 1);
+
+  const HmiLevel test_level_1 = HL_FULL;
+  const HmiLevel test_level_2 = HL_LIMITED;
+  const policy_table::Parameter test_parameter_1 = P_GPS;
+  const policy_table::Parameter test_parameter_2 = P_SPEED;
+
+  Rpcs rpcs;
+
+  rpcs.disallowed_by_ccs_entities_off->push_back(off_entity_1);
+  rpcs.disallowed_by_ccs_entities_off->push_back(off_entity_2);
+
+  rpcs.disallowed_by_ccs_entities_on->push_back(on_entity_1);
+  rpcs.disallowed_by_ccs_entities_on->push_back(on_entity_2);
+
+  *rpcs.user_consent_prompt = user_consent_prompt;
+
+  RpcParameters parameters;
+  parameters.hmi_levels.push_back(test_level_1);
+  parameters.hmi_levels.push_back(test_level_2);
+  parameters.parameters->push_back(test_parameter_1);
+  parameters.parameters->push_back(test_parameter_2);
+  rpcs.rpcs.insert(std::make_pair(rpc_name, parameters));
+
+  Table original_table;
+  FunctionalGroupings& groupings =
+      original_table.policy_table.functional_groupings;
+  groupings.insert(std::make_pair(group_name, rpcs));
+
+  CCS_Entity off_entity_3(3, 4);
+  CCS_Entity on_entity_3(5, 6);
+
+  Rpcs another_rpcs;
+
+  another_rpcs.disallowed_by_ccs_entities_off->push_back(off_entity_3);
+  another_rpcs.disallowed_by_ccs_entities_on->push_back(on_entity_3);
+  *another_rpcs.user_consent_prompt = another_user_consent_prompt;
+
+  const HmiLevel test_level_3 = HL_BACKGROUND;
+  const policy_table::Parameter test_parameter_3 = P_BELTSTATUS;
+
+  RpcParameters another_parameters;
+  another_parameters.hmi_levels.push_back(test_level_3);
+  another_parameters.parameters->push_back(test_parameter_3);
+  another_rpcs.rpcs.insert(std::make_pair(rpc_name, another_parameters));
+
+  groupings.insert(std::make_pair(another_group_name, another_rpcs));
+
+  // Act
+  EXPECT_TRUE(reps_->Save(original_table));
+  utils::SharedPtr<Table> loaded_table = reps_->GenerateSnapshot();
+
+  FunctionalGroupings loaded_groupings =
+      GetData<Table, FunctionalGroupings>(*loaded_table);
+
+  Rpcs loaded_rpcs =
+      GetKeyData<FunctionalGroupings, Rpcs>(loaded_groupings, group_name);
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_off, off_entity_1)));
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_off, off_entity_2)));
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_on, on_entity_1)));
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_on, on_entity_2)));
+
+  RpcParameters loaded_parameters =
+      GetKeyData<Rpc, RpcParameters>(loaded_rpcs.rpcs, rpc_name);
+
+  EXPECT_TRUE(
+      (IsKeyExist<HmiLevels>(loaded_parameters.hmi_levels, test_level_1)));
+  EXPECT_TRUE(
+      (IsKeyExist<HmiLevels>(loaded_parameters.hmi_levels, test_level_2)));
+
+  EXPECT_TRUE((
+      IsKeyExist<Parameters>(*loaded_parameters.parameters, test_parameter_1)));
+  EXPECT_TRUE((
+      IsKeyExist<Parameters>(*loaded_parameters.parameters, test_parameter_2)));
+
+  Rpcs another_loaded_rpcs = GetKeyData<FunctionalGroupings, Rpcs>(
+      loaded_groupings, another_group_name);
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *another_loaded_rpcs.disallowed_by_ccs_entities_off, off_entity_3)));
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *another_loaded_rpcs.disallowed_by_ccs_entities_on, on_entity_3)));
+
+  RpcParameters another_loaded_parameters =
+      GetKeyData<Rpc, RpcParameters>(another_loaded_rpcs.rpcs, rpc_name);
+
+  EXPECT_TRUE((IsKeyExist<HmiLevels>(another_loaded_parameters.hmi_levels,
+                                     test_level_3)));
+
+  EXPECT_TRUE((IsKeyExist<Parameters>(*another_loaded_parameters.parameters,
+                                      test_parameter_3)));
+}
+
+TEST_F(SQLPTExtRepresentationTest, JsonContentsCCS_ExpectParsed) {
+  using namespace policy_table;
+  using namespace rpc;
+
+  const std::string group_name = "GroupName";
+  const int32_t entity_on_type = 1;
+  const int32_t entity_on_id = 2;
+  const int32_t entity_off_type = 3;
+  const int32_t entity_off_id = 4;
+
+  Json::Value json_table(Json::objectValue);
+  json_table["policy_table"] = Json::Value(Json::objectValue);
+
+  Json::Value& policy_table = json_table["policy_table"];
+  policy_table["functional_groupings"] = Json::Value(Json::objectValue);
+
+  Json::Value& functional_groupings = policy_table["functional_groupings"];
+  functional_groupings[group_name] = Json::Value(Json::objectValue);
+  functional_groupings[group_name]["rpcs"];
+
+  Json::Value entity_on = Json::Value(Json::objectValue);
+  entity_on["entityType"] = entity_on_type;
+  entity_on["entityID"] = entity_on_id;
+
+  functional_groupings[group_name]["disallowed_by_ccs_entities_on"][0] =
+      entity_on;
+
+  Json::Value entity_off = Json::Value(Json::objectValue);
+  entity_off["entityType"] = entity_off_type;
+  entity_off["entityID"] = entity_off_id;
+  functional_groupings[group_name]["disallowed_by_ccs_entities_off"][0] =
+      entity_off;
+
+  policy_table::Table parsed_table(&json_table);
+
+  FunctionalGroupings loaded_groupings =
+      GetData<Table, FunctionalGroupings>(parsed_table);
+
+  Rpcs loaded_rpcs =
+      GetKeyData<FunctionalGroupings, Rpcs>(loaded_groupings, group_name);
+
+  CCS_Entity off_entity_1(entity_off_type, entity_off_id);
+  CCS_Entity on_entity_1(entity_on_type, entity_on_id);
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_off, off_entity_1)));
+
+  EXPECT_TRUE((IsKeyExist<DisallowedByCCSEntities>(
+      *loaded_rpcs.disallowed_by_ccs_entities_on, on_entity_1)));
+}
+
+TEST_F(SQLPTExtRepresentationTest, SaveCCSStatus_ExpectSaved) {
+  CCSStatusItem item_1(0, 0, kStatusOn);
+  CCSStatusItem item_2(1, 1, kStatusOff);
+  CCSStatus in_status;
+  in_status.insert(item_1);
+  in_status.insert(item_2);
+
+  EXPECT_TRUE(reps_->SaveCCSStatus(in_status));
+
+  CCSStatus out_status = reps_->GetCCSStatus();
+  EXPECT_TRUE(in_status.size() == out_status.size());
+
+  EXPECT_TRUE(out_status.end() !=
+              find(out_status.begin(), out_status.end(), item_1));
+  EXPECT_TRUE(out_status.end() !=
+              find(out_status.begin(), out_status.end(), item_2));
 }
 
 }  // namespace policy_test