Final formating changed files

11 files changed, 378 insertions, 286 deletions

diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index 7106f81d2e..b79c022a20 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -70,7 +70,7 @@
 #ifdef ENABLE_SECURITY
 #include "security_manager/security_manager_listener.h"
 #include "security_manager/ssl_context.h"
-#endif // ENABLE_SECURITY
+#endif  // ENABLE_SECURITY
 
 #ifdef TIME_TESTER
 #include "time_metric_observer.h"
@@ -168,13 +168,13 @@ struct MessageToHmi : public utils::SharedPtr<Message> {
 };
 
 // Short type names for prioritized message queues
-typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromMobile> >
+typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromMobile>>
     FromMobileQueue;
-typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToMobile> >
+typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToMobile>>
     ToMobileQueue;
-typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromHmi> >
+typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromHmi>>
     FromHmiQueue;
-typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToHmi> >
+typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToHmi>>
     ToHmiQueue;
 
 // AudioPassThru
@@ -259,8 +259,8 @@ class ApplicationManagerImpl
   ApplicationSharedPtr get_limited_voice_application() const;
 
   void OnHMILevelChanged(uint32_t app_id,
-                                 mobile_apis::HMILevel::eType from,
-                                 mobile_apis::HMILevel::eType to) OVERRIDE;
+                         mobile_apis::HMILevel::eType from,
+                         mobile_apis::HMILevel::eType to) OVERRIDE;
 
   void SendHMIStatusNotification(const ApplicationSharedPtr app) OVERRIDE;
   /**
@@ -597,7 +597,7 @@ class ApplicationManagerImpl
    * for app with HMI level BACKGROUND.
    */
   void OnUpdateHMIAppType(
-      std::map<std::string, std::vector<std::string> > app_hmi_types) OVERRIDE;
+      std::map<std::string, std::vector<std::string>> app_hmi_types) OVERRIDE;
 
   /*
    * @brief Starts audio pass thru thread
@@ -1275,9 +1275,9 @@ class ApplicationManagerImpl
    * 1st value - is video service opened or not
    * 2nd value - is audio service opened or not
    */
-  typedef std::map<uint32_t, std::pair<bool, bool> > NaviServiceStatusMap;
+  typedef std::map<uint32_t, std::pair<bool, bool>> NaviServiceStatusMap;
 
-  typedef SharedPtr<TimerThread<ApplicationManagerImpl> >
+  typedef SharedPtr<TimerThread<ApplicationManagerImpl>>
       ApplicationManagerTimerPtr;
 
   /**
diff --git a/src/components/application_manager/include/application_manager/hmi_state.h b/src/components/application_manager/include/application_manager/hmi_state.h
index 68f8519b21..f9a862ef43 100644
--- a/src/components/application_manager/include/application_manager/hmi_state.h
+++ b/src/components/application_manager/include/application_manager/hmi_state.h
@@ -203,7 +203,8 @@ class HmiState {
  */
 class VRHmiState : public HmiState {
  public:
-  mobile_apis::AudioStreamingState::eType audio_streaming_state() const OVERRIDE;
+  mobile_apis::AudioStreamingState::eType audio_streaming_state()
+      const OVERRIDE;
   VRHmiState(uint32_t app_id, ApplicationManager* app_mngr);
 };
 
@@ -213,7 +214,8 @@ class VRHmiState : public HmiState {
 class TTSHmiState : public HmiState {
  public:
   TTSHmiState(uint32_t app_id, ApplicationManager* app_mngr);
-  mobile_apis::AudioStreamingState::eType audio_streaming_state() const OVERRIDE;
+  mobile_apis::AudioStreamingState::eType audio_streaming_state()
+      const OVERRIDE;
 };
 
 /**
@@ -223,7 +225,8 @@ class TTSHmiState : public HmiState {
 class NaviStreamingHmiState : public HmiState {
  public:
   NaviStreamingHmiState(uint32_t app_id, ApplicationManager* app_mngr);
-  mobile_apis::AudioStreamingState::eType audio_streaming_state() const OVERRIDE;
+  mobile_apis::AudioStreamingState::eType audio_streaming_state()
+      const OVERRIDE;
 };
 
 /**
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 90f4916251..c95b1344af 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -1080,7 +1080,7 @@ bool ApplicationManagerImpl::StartNaviService(
     if (navi_service_status_.end() == it) {
       std::pair<NaviServiceStatusMap::iterator, bool> res =
           navi_service_status_.insert(
-              std::pair<uint32_t, std::pair<bool, bool> >(
+              std::pair<uint32_t, std::pair<bool, bool>>(
                   app_id, std::make_pair(false, false)));
       if (!res.second) {
         LOG4CXX_WARN(logger_, "Navi service refused");
@@ -3247,10 +3247,10 @@ bool ApplicationManagerImpl::CompareAppHMIType(
 }
 
 void ApplicationManagerImpl::OnUpdateHMIAppType(
-    std::map<std::string, std::vector<std::string> > app_hmi_types) {
+    std::map<std::string, std::vector<std::string>> app_hmi_types) {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  std::map<std::string, std::vector<std::string> >::iterator
+  std::map<std::string, std::vector<std::string>>::iterator
       it_app_hmi_types_from_policy;
   std::vector<std::string> hmi_types_from_policy;
   smart_objects::SmartObject transform_app_hmi_types(
diff --git a/src/components/application_manager/src/application_state.cc b/src/components/application_manager/src/application_state.cc
index 34ef2e4860..101a565a8e 100644
--- a/src/components/application_manager/src/application_state.cc
+++ b/src/components/application_manager/src/application_state.cc
@@ -119,10 +119,9 @@ void ApplicationState::AddHMIState(HmiStatePtr state) {
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(state);
   sync_primitives::AutoLock auto_lock(hmi_states_lock_);
-  HmiStates::iterator it =
-      std::find_if(hmi_states_.begin(),
-                   hmi_states_.end(),
-                   StateIDComparator(state->state_id()));
+  HmiStates::iterator it = std::find_if(hmi_states_.begin(),
+                                        hmi_states_.end(),
+                                        StateIDComparator(state->state_id()));
   if (hmi_states_.end() != it) {
     LOG4CXX_WARN(
         logger_,
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 4475a57171..7c7857d797 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -311,19 +311,19 @@ void MessageHelper::SendOnAppRegisteredNotificationToHMI(
   }
 
   if (application_impl.IsRegistered()) {
-  std::vector<std::string> request_types =
-      policy::PolicyHandler::instance()->GetAppRequestTypes(
+    std::vector<std::string> request_types =
+        policy::PolicyHandler::instance()->GetAppRequestTypes(
             application_impl.mobile_app_id());
 
-  application[strings::request_type] = SmartObject(SmartType_Array);
-  smart_objects::SmartObject& request_array =
-      application[strings::request_type];
+    application[strings::request_type] = SmartObject(SmartType_Array);
+    smart_objects::SmartObject& request_array =
+        application[strings::request_type];
 
-  uint32_t index = 0;
-  std::vector<std::string>::const_iterator it = request_types.begin();
-  for (; request_types.end() != it; ++it) {
-    request_array[index] = *it;
-    ++index;
+    uint32_t index = 0;
+    std::vector<std::string>::const_iterator it = request_types.begin();
+    for (; request_types.end() != it; ++it) {
+      request_array[index] = *it;
+      ++index;
     }
   }
 
@@ -402,7 +402,7 @@ smart_objects::SmartObject* MessageHelper::GetLockScreenIconUrlNotification(
       policy::PolicyHandler::instance()->GetLockScreenIconUrl();
 
   return message;
-  }
+}
 void MessageHelper::SendLockScreenIconUrlNotification(
     const uint32_t connection_key) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -420,11 +420,11 @@ void MessageHelper::SendHashUpdateNotification(const uint32_t app_id) {
   if (so) {
     PrintSmartObject(*so);
     if (!ApplicationManagerImpl::instance()->ManageMobileCommand(so)) {
-    LOG4CXX_ERROR(logger_, "Failed to send HashUpdate notification.");
-  } else {
-    ApplicationManagerImpl::instance()
-        ->resume_controller()
-        .ApplicationsDataUpdated();
+      LOG4CXX_ERROR(logger_, "Failed to send HashUpdate notification.");
+    } else {
+      ApplicationManagerImpl::instance()
+          ->resume_controller()
+          .ApplicationsDataUpdated();
     }
   }
 }
@@ -1261,7 +1261,6 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateChangeRegistration(
 
   params[strings::msg_params] = msg_params;
   return command;
-
 }
 
 void MessageHelper::SendUIChangeRegistrationRequestToHMI(
@@ -1394,8 +1393,8 @@ bool MessageHelper::CreateHMIApplicationStruct(
   }
 
   if (app->IsRegistered()) {
-  output[strings::hmi_display_language_desired] = app->ui_language();
-  output[strings::is_media_application] = app->is_media_application();
+    output[strings::hmi_display_language_desired] = app->ui_language();
+    output[strings::is_media_application] = app->is_media_application();
   } else {
     output[strings::greyOut] = app->is_greyed_out();
     const SmartObject* app_tts_name = app->tts_name();
@@ -1743,7 +1742,6 @@ void MessageHelper::SendGetUserFriendlyMessageResponse(
   smart_objects::SmartObject& user_friendly_messages =
       (*message)[strings::msg_params][messages];
 
-
   const std::string message_code = "messageCode";
 
   std::vector<policy::UserFriendlyMessage>::const_iterator it = msg.begin();
@@ -1754,7 +1752,6 @@ void MessageHelper::SendGetUserFriendlyMessageResponse(
 
     smart_objects::SmartObject& obj = user_friendly_messages[index];
     obj[message_code] = it->message_code;
-
   }
 
   ApplicationManagerImpl::instance()->ManageHMICommand(message);
@@ -2550,7 +2547,6 @@ mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(
         break;
       }
       case SoftButtonType::SBT_TEXT: {
-
         if ((!request_soft_buttons[i].keyExists(strings::text)) ||
             (!VerifySoftButtonString(
                 request_soft_buttons[i][strings::text].asString()))) {
diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc
index 848ff96980..dd13e40fc5 100644
--- a/src/components/application_manager/test/mock_message_helper.cc
+++ b/src/components/application_manager/test/mock_message_helper.cc
@@ -239,10 +239,10 @@ void MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(
       ->SendAllOnButtonSubscriptionNotificationsForApp(app);
 }
 
-
-uint32_t MessageHelper::SendActivateAppToHMI(uint32_t const app_id,
-         hmi_apis::Common_HMILevel::eType level,
-         bool send_policy_priority) {
+uint32_t MessageHelper::SendActivateAppToHMI(
+    uint32_t const app_id,
+    hmi_apis::Common_HMILevel::eType level,
+    bool send_policy_priority) {
   return MockMessageHelper::message_helper_mock()->SendActivateAppToHMI(
       app_id, level, send_policy_priority);
 }
diff --git a/src/components/application_manager/test/mock_message_helper.h b/src/components/application_manager/test/mock_message_helper.h
index 1d543f9b89..cf4c6f2411 100644
--- a/src/components/application_manager/test/mock_message_helper.h
+++ b/src/components/application_manager/test/mock_message_helper.h
@@ -128,9 +128,9 @@ class MockMessageHelper {
                void(ApplicationConstSharedPtr app));
 
   MOCK_METHOD3(SendActivateAppToHMI,
-                     uint32_t(uint32_t const app_id,
-                              hmi_apis::Common_HMILevel::eType level,
-                              bool send_policy_priority));
+               uint32_t(uint32_t const app_id,
+                        hmi_apis::Common_HMILevel::eType level,
+                        bool send_policy_priority));
 
   MOCK_METHOD1(SendOnResumeAudioSourceToHMI, void(uint32_t app_id));
   MOCK_METHOD1(CreateAddSubMenuRequestToHMI,
diff --git a/src/components/application_manager/test/request_info_test.cc b/src/components/application_manager/test/request_info_test.cc
index d4f67e67f4..92692703e3 100644
--- a/src/components/application_manager/test/request_info_test.cc
+++ b/src/components/application_manager/test/request_info_test.cc
@@ -60,17 +60,24 @@ class MockRequest : public application_manager::commands::Command {
 
   uint32_t connection_key_;
   uint32_t correlation_id_;
-  virtual uint32_t connection_key() const { return connection_key_; }
-  virtual uint32_t correlation_id() const { return correlation_id_; }
+  virtual uint32_t connection_key() const {
+    return connection_key_;
+  }
+  virtual uint32_t correlation_id() const {
+    return correlation_id_;
+  }
 };
 
 class TestRequestInfo : public request_info::RequestInfo {
  public:
   TestRequestInfo(request_info::RequestPtr request,
                   const RequestType requst_type,
-                  const TimevalStruct& start_time, const uint64_t timeout_msec)
+                  const TimevalStruct& start_time,
+                  const uint64_t timeout_msec)
       : RequestInfo(request, requst_type, start_time, timeout_msec) {}
-  void SetEndTime(const TimevalStruct& end_time) { end_time_ = end_time; }
+  void SetEndTime(const TimevalStruct& end_time) {
+    end_time_ = end_time;
+  }
 };
 
 class RequestInfoTest : public ::testing::Test {
@@ -93,20 +100,22 @@ class RequestInfoTest : public ::testing::Test {
   uint32_t mobile_correlation_id;
 
   utils::SharedPtr<TestRequestInfo> CreateTestInfo(
-      uint32_t connection_key, uint32_t correlation_id,
+      uint32_t connection_key,
+      uint32_t correlation_id,
       request_info::RequestInfo::RequestType requst_type,
-      const TimevalStruct& start_time, uint64_t timeout_msec) {
+      const TimevalStruct& start_time,
+      uint64_t timeout_msec) {
     utils::SharedPtr<MockRequest> mock_request =
         utils::MakeShared<MockRequest>(connection_key, correlation_id);
     utils::SharedPtr<TestRequestInfo> request =
-        utils::MakeShared<TestRequestInfo>(mock_request, requst_type,
-                                           start_time, timeout_msec);
+        utils::MakeShared<TestRequestInfo>(
+            mock_request, requst_type, start_time, timeout_msec);
     return request;
   }
 };
 
 TEST_F(RequestInfoTest, RequestInfoEqualEndTime) {
-  std::vector<utils::SharedPtr<TestRequestInfo> > requests;
+  std::vector<utils::SharedPtr<TestRequestInfo>> requests;
   const TimevalStruct& time = date_time::DateTime::getCurrentTime();
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
     utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
@@ -119,9 +128,12 @@ TEST_F(RequestInfoTest, RequestInfoEqualEndTime) {
 
 TEST_F(RequestInfoTest, AddRemoveHMIRequests) {
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        hmi_connection_key_, i, request_info::RequestInfo::HMIRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(hmi_connection_key_,
+                       i,
+                       request_info::RequestInfo::HMIRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
     EXPECT_TRUE(request_info_set_.Add(request));
     EXPECT_TRUE(request_info_set_.RemoveRequest(request));
   }
@@ -130,20 +142,23 @@ TEST_F(RequestInfoTest, AddRemoveHMIRequests) {
 }
 
 TEST_F(RequestInfoTest, AddHMIRequests_RemoveAllRequests) {
-  std::vector<utils::SharedPtr<TestRequestInfo> > requests;
+  std::vector<utils::SharedPtr<TestRequestInfo>> requests;
 
   // Add hmi requests
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        hmi_connection_key_, i, request_info::RequestInfo::HMIRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(hmi_connection_key_,
+                       i,
+                       request_info::RequestInfo::HMIRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
     requests.push_back(request);
     EXPECT_TRUE(request_info_set_.Add(request));
   }
   EXPECT_EQ(count_of_requests_for_test_, request_info_set_.Size());
 
   // Delete every request
-  std::vector<utils::SharedPtr<TestRequestInfo> >::iterator req_it =
+  std::vector<utils::SharedPtr<TestRequestInfo>>::iterator req_it =
       requests.begin();
 
   for (; req_it != requests.end(); ++req_it) {
@@ -167,11 +182,14 @@ TEST_F(RequestInfoTest, CheckRequestsMaxCount) {
   const uint32_t hmi_level_count = 1000;
 
   // Count of added requests is less than max possible
-  std::vector<utils::SharedPtr<TestRequestInfo> > requests;
+  std::vector<utils::SharedPtr<TestRequestInfo>> requests;
   for (uint32_t i = 0; i < hmi_level_count - 1; ++i) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        mobile_connection_key1_, i, request_info::RequestInfo::MobileRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(mobile_connection_key1_,
+                       i,
+                       request_info::RequestInfo::MobileRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
 
     request->set_hmi_level(mobile_apis::HMILevel::HMI_FULL);
     requests.push_back(request);
@@ -180,27 +198,35 @@ TEST_F(RequestInfoTest, CheckRequestsMaxCount) {
   EXPECT_EQ(hmi_level_count - 1, request_info_set_.Size());
 
   EXPECT_TRUE(request_info_set_.CheckHMILevelTimeScaleMaxRequest(
-      mobile_apis::HMILevel::HMI_FULL, mobile_connection_key1_,
-      app_hmi_level_time_scale, hmi_level_count));
+      mobile_apis::HMILevel::HMI_FULL,
+      mobile_connection_key1_,
+      app_hmi_level_time_scale,
+      hmi_level_count));
 
   // Adding new request is correct
   utils::SharedPtr<TestRequestInfo> new_request =
-      CreateTestInfo(mobile_connection_key1_, hmi_level_count,
+      CreateTestInfo(mobile_connection_key1_,
+                     hmi_level_count,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(), default_timeout_);
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
   new_request->set_hmi_level(mobile_apis::HMILevel::HMI_FULL);
   EXPECT_TRUE(request_info_set_.Add(new_request));
   EXPECT_EQ(hmi_level_count, request_info_set_.Size());
 
   // Count of added requests is max
   EXPECT_FALSE(request_info_set_.CheckHMILevelTimeScaleMaxRequest(
-      mobile_apis::HMILevel::HMI_FULL, mobile_connection_key1_,
-      app_hmi_level_time_scale, hmi_level_count));
+      mobile_apis::HMILevel::HMI_FULL,
+      mobile_connection_key1_,
+      app_hmi_level_time_scale,
+      hmi_level_count));
 
   utils::SharedPtr<TestRequestInfo> new_request2 =
-      CreateTestInfo(mobile_connection_key1_, hmi_level_count + 1,
+      CreateTestInfo(mobile_connection_key1_,
+                     hmi_level_count + 1,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(), default_timeout_);
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
 
   EXPECT_TRUE(request_info_set_.Add(new_request2));
 }
@@ -210,11 +236,14 @@ TEST_F(RequestInfoTest, CheckMaxCountOfRequest) {
   const uint32_t hmi_level_count = 1000;
 
   // Count of added requests is less than max possible
-  std::vector<utils::SharedPtr<TestRequestInfo> > requests;
+  std::vector<utils::SharedPtr<TestRequestInfo>> requests;
   for (uint32_t i = 0; i < hmi_level_count - 1; ++i) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        mobile_connection_key1_, i, request_info::RequestInfo::MobileRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(mobile_connection_key1_,
+                       i,
+                       request_info::RequestInfo::MobileRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
     request->set_hmi_level(mobile_apis::HMILevel::HMI_FULL);
     requests.push_back(request);
     EXPECT_TRUE(request_info_set_.Add(request));
@@ -226,9 +255,11 @@ TEST_F(RequestInfoTest, CheckMaxCountOfRequest) {
 
   // Adding new request is correct
   utils::SharedPtr<TestRequestInfo> new_request =
-      CreateTestInfo(mobile_connection_key1_, hmi_level_count,
+      CreateTestInfo(mobile_connection_key1_,
+                     hmi_level_count,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(), default_timeout_);
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
   new_request->set_hmi_level(mobile_apis::HMILevel::HMI_FULL);
   EXPECT_TRUE(request_info_set_.Add(new_request));
   EXPECT_EQ(hmi_level_count, request_info_set_.Size());
@@ -238,21 +269,29 @@ TEST_F(RequestInfoTest, CheckMaxCountOfRequest) {
       mobile_connection_key1_, app_hmi_level_time_scale, hmi_level_count));
 
   utils::SharedPtr<TestRequestInfo> new_request2 =
-      CreateTestInfo(mobile_connection_key1_, hmi_level_count + 1,
+      CreateTestInfo(mobile_connection_key1_,
+                     hmi_level_count + 1,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(), default_timeout_);
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
 
   EXPECT_TRUE(request_info_set_.Add(new_request2));
 }
 
 TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequests) {
-  utils::SharedPtr<TestRequestInfo> mobile_request1 = CreateTestInfo(
-      mobile_connection_key1_, 12345, request_info::RequestInfo::MobileRequest,
-      date_time::DateTime::getCurrentTime(), default_timeout_);
+  utils::SharedPtr<TestRequestInfo> mobile_request1 =
+      CreateTestInfo(mobile_connection_key1_,
+                     12345,
+                     request_info::RequestInfo::MobileRequest,
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
   EXPECT_TRUE(request_info_set_.Add(mobile_request1));
-  utils::SharedPtr<TestRequestInfo> mobile_request2 = CreateTestInfo(
-      mobile_connection_key2_, 54321, request_info::RequestInfo::MobileRequest,
-      date_time::DateTime::getCurrentTime(), default_timeout_);
+  utils::SharedPtr<TestRequestInfo> mobile_request2 =
+      CreateTestInfo(mobile_connection_key2_,
+                     54321,
+                     request_info::RequestInfo::MobileRequest,
+                     date_time::DateTime::getCurrentTime(),
+                     default_timeout_);
   EXPECT_TRUE(request_info_set_.Add(mobile_request2));
   EXPECT_EQ(2u, request_info_set_.Size());
   EXPECT_EQ(2u, request_info_set_.RemoveMobileRequests());
@@ -260,13 +299,16 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequests) {
 }
 
 TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequestsByConnectionKey) {
-  std::vector<utils::SharedPtr<TestRequestInfo> > requests;
+  std::vector<utils::SharedPtr<TestRequestInfo>> requests;
   const uint32_t count_of_mobile_request1 = 200;
   const uint32_t count_of_mobile_request2 = 100;
   for (uint32_t i = 0; i < count_of_mobile_request1; ++i) {
-    utils::SharedPtr<TestRequestInfo> mobile_request1 = CreateTestInfo(
-        mobile_connection_key1_, i, request_info::RequestInfo::MobileRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> mobile_request1 =
+        CreateTestInfo(mobile_connection_key1_,
+                       i,
+                       request_info::RequestInfo::MobileRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
 
     requests.push_back(mobile_request1);
     EXPECT_TRUE(request_info_set_.Add(mobile_request1));
@@ -274,9 +316,12 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequestsByConnectionKey) {
   EXPECT_EQ(count_of_mobile_request1, request_info_set_.Size());
 
   for (uint32_t i = 0; i < count_of_mobile_request2; ++i) {
-    utils::SharedPtr<TestRequestInfo> mobile_request2 = CreateTestInfo(
-        mobile_connection_key2_, i, request_info::RequestInfo::MobileRequest,
-        date_time::DateTime::getCurrentTime(), default_timeout_);
+    utils::SharedPtr<TestRequestInfo> mobile_request2 =
+        CreateTestInfo(mobile_connection_key2_,
+                       i,
+                       request_info::RequestInfo::MobileRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       default_timeout_);
 
     requests.push_back(mobile_request2);
     EXPECT_TRUE(request_info_set_.Add(mobile_request2));
@@ -293,9 +338,12 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequestsByConnectionKey) {
 
 TEST_F(RequestInfoTest, RequestInfoSetFront) {
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        mobile_connection_key1_, i, request_info::RequestInfo::HMIRequest,
-        date_time::DateTime::getCurrentTime(), i);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(mobile_connection_key1_,
+                       i,
+                       request_info::RequestInfo::HMIRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       i);
     request_info_set_.Add(request);
   }
 
@@ -313,20 +361,23 @@ TEST_F(RequestInfoTest, RequestInfoSetFront) {
 }
 
 TEST_F(RequestInfoTest, RequestInfoSetFind) {
-  std::vector<std::pair<uint32_t, uint32_t> > appid_connection_id;
+  std::vector<std::pair<uint32_t, uint32_t>> appid_connection_id;
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
     appid_connection_id.push_back(
         std::pair<uint32_t, uint32_t>(i, count_of_requests_for_test_ - i));
   }
-  std::vector<std::pair<uint32_t, uint32_t> >::iterator req_it =
+  std::vector<std::pair<uint32_t, uint32_t>>::iterator req_it =
       appid_connection_id.begin();
-  const std::vector<std::pair<uint32_t, uint32_t> >::iterator end =
+  const std::vector<std::pair<uint32_t, uint32_t>>::iterator end =
       appid_connection_id.end();
 
   for (; req_it != end; ++req_it) {
-    utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-        req_it->first, req_it->second, request_info::RequestInfo::HMIRequest,
-        date_time::DateTime::getCurrentTime(), 10);
+    utils::SharedPtr<TestRequestInfo> request =
+        CreateTestInfo(req_it->first,
+                       req_it->second,
+                       request_info::RequestInfo::HMIRequest,
+                       date_time::DateTime::getCurrentTime(),
+                       10);
     EXPECT_TRUE(request_info_set_.Add(request));
   }
 
@@ -350,9 +401,12 @@ TEST_F(RequestInfoTest, RequestInfoSetEqualHash) {
   request_info::RequestInfoSet request_info_set;
   const uint32_t connection_key = 65483;
   const uint32_t corr_id = 65483;
-  utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-      connection_key, corr_id, request_info::RequestInfo::HMIRequest,
-      date_time::DateTime::getCurrentTime(), 10);
+  utils::SharedPtr<TestRequestInfo> request =
+      CreateTestInfo(connection_key,
+                     corr_id,
+                     request_info::RequestInfo::HMIRequest,
+                     date_time::DateTime::getCurrentTime(),
+                     10);
   EXPECT_TRUE(request_info_set.Add(request));
   EXPECT_FALSE(request_info_set.Add(request));
   EXPECT_FALSE(request_info_set.Add(request));
@@ -383,9 +437,12 @@ TEST_F(RequestInfoTest, EndTimeisExpired) {
   TimevalStruct expired = date_time::DateTime::getCurrentTime();
   expired.tv_sec = std::numeric_limits<time_t>::max();
 
-  utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-      mobile_connection_key1_, mobile_correlation_id,
-      request_info::RequestInfo::MobileRequest, time, default_timeout_);
+  utils::SharedPtr<TestRequestInfo> request =
+      CreateTestInfo(mobile_connection_key1_,
+                     mobile_correlation_id,
+                     request_info::RequestInfo::MobileRequest,
+                     time,
+                     default_timeout_);
 
   request->SetEndTime(expired);
   EXPECT_FALSE(request->isExpired());
@@ -396,9 +453,12 @@ TEST_F(RequestInfoTest, EndTimeisExpired) {
 
 TEST_F(RequestInfoTest, UpdateEndTime) {
   TimevalStruct time = date_time::DateTime::getCurrentTime();
-  utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-      mobile_connection_key1_, mobile_correlation_id,
-      request_info::RequestInfo::MobileRequest, time, default_timeout_);
+  utils::SharedPtr<TestRequestInfo> request =
+      CreateTestInfo(mobile_connection_key1_,
+                     mobile_correlation_id,
+                     request_info::RequestInfo::MobileRequest,
+                     time,
+                     default_timeout_);
   request->SetEndTime(time);
   request->updateEndTime();
   TimevalStruct last_time = request->end_time();
@@ -407,9 +467,12 @@ TEST_F(RequestInfoTest, UpdateEndTime) {
 
 TEST_F(RequestInfoTest, UpdateTimeOut) {
   TimevalStruct time = date_time::DateTime::getCurrentTime();
-  utils::SharedPtr<TestRequestInfo> request = CreateTestInfo(
-      mobile_connection_key1_, mobile_correlation_id,
-      request_info::RequestInfo::MobileRequest, time, default_timeout_);
+  utils::SharedPtr<TestRequestInfo> request =
+      CreateTestInfo(mobile_connection_key1_,
+                     mobile_correlation_id,
+                     request_info::RequestInfo::MobileRequest,
+                     time,
+                     default_timeout_);
   request->SetEndTime(time);
   request->updateEndTime();
 
diff --git a/src/components/application_manager/test/resumption/include/application_mock.h b/src/components/application_manager/test/resumption/include/application_mock.h
index df5fcd2b10..9c9e66dcf6 100644
--- a/src/components/application_manager/test/resumption/include/application_mock.h
+++ b/src/components/application_manager/test/resumption/include/application_mock.h
@@ -186,10 +186,10 @@ class ApplicationMock : public ::application_manager::Application {
   MOCK_CONST_METHOD0(tbt_show_command, const smart_objects::SmartObject*());
   MOCK_CONST_METHOD0(
       SubscribedButtons,
-      DataAccessor< ::application_manager::ButtonSubscriptions>());
+      DataAccessor<::application_manager::ButtonSubscriptions>());
   MOCK_CONST_METHOD0(
       SubscribedIVI,
-      DataAccessor< ::application_manager::VehicleInfoSubscriptions>());
+      DataAccessor<::application_manager::VehicleInfoSubscriptions>());
   MOCK_CONST_METHOD0(keyboard_props, const smart_objects::SmartObject*());
   MOCK_CONST_METHOD0(menu_title, const smart_objects::SmartObject*());
   MOCK_CONST_METHOD0(menu_icon, const smart_objects::SmartObject*());
@@ -247,13 +247,13 @@ class ApplicationMock : public ::application_manager::Application {
                void(uint32_t correlation_id));
   MOCK_CONST_METHOD0(
       performinteraction_choice_set_map,
-      DataAccessor< ::application_manager::PerformChoiceSetMap>());
+      DataAccessor<::application_manager::PerformChoiceSetMap>());
   MOCK_CONST_METHOD0(commands_map,
-                     DataAccessor< ::application_manager::CommandsMap>());
+                     DataAccessor<::application_manager::CommandsMap>());
   MOCK_CONST_METHOD0(sub_menu_map,
-                     DataAccessor< ::application_manager::SubMenuMap>());
+                     DataAccessor<::application_manager::SubMenuMap>());
   MOCK_CONST_METHOD0(choice_set_map,
-                     DataAccessor< ::application_manager::ChoiceSetMap>());
+                     DataAccessor<::application_manager::ChoiceSetMap>());
   MOCK_METHOD1(set_perform_interaction_active, void(uint32_t active));
   MOCK_CONST_METHOD0(is_perform_interaction_active, uint32_t());
   MOCK_METHOD1(set_perform_interaction_mode, void(int32_t mode));
diff --git a/src/components/application_manager/test/state_controller/include/state_controller_mock.h b/src/components/application_manager/test/state_controller/include/state_controller_mock.h
index 0fbcd9abd3..d3e2c8b4ce 100644
--- a/src/components/application_manager/test/state_controller/include/state_controller_mock.h
+++ b/src/components/application_manager/test/state_controller/include/state_controller_mock.h
@@ -43,17 +43,20 @@
 namespace state_controller_test {
 namespace am = application_manager;
 
-class StateControllerMock :public am::StateController {
+class StateControllerMock : public am::StateController {
  public:
-  MOCK_METHOD2(SetRegularState, void (
-      am::ApplicationSharedPtr, const mobile_apis::AudioStreamingState::eType));
-  MOCK_METHOD2(SetRegularState, void (
-      am::ApplicationSharedPtr, const mobile_apis::SystemContext::eType));
-  MOCK_METHOD3(OnStateChanged, void (
-      am::ApplicationSharedPtr, am::HmiStatePtr, am::HmiStatePtr));
-  MOCK_METHOD0(OnNaviStreamingStarted, void ());
-  MOCK_METHOD0(OnNaviStreamingStopped, void ());
+  MOCK_METHOD2(SetRegularState,
+               void(am::ApplicationSharedPtr,
+                    const mobile_apis::AudioStreamingState::eType));
+  MOCK_METHOD2(SetRegularState,
+               void(am::ApplicationSharedPtr,
+                    const mobile_apis::SystemContext::eType));
+  MOCK_METHOD3(OnStateChanged,
+               void(am::ApplicationSharedPtr,
+                    am::HmiStatePtr,
+                    am::HmiStatePtr));
+  MOCK_METHOD0(OnNaviStreamingStarted, void());
+  MOCK_METHOD0(OnNaviStreamingStopped, void());
 };
-
 }
-#endif // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATE_CONTROLLER_MOCK
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_TEST_STATE_CONTROLLER_INCLUDE_STATE_CONTROLLER_MOCK
diff --git a/src/components/application_manager/test/state_controller/state_controller_test.cc b/src/components/application_manager/test/state_controller/state_controller_test.cc
index 342df545d6..70bc9a3525 100644
--- a/src/components/application_manager/test/state_controller/state_controller_test.cc
+++ b/src/components/application_manager/test/state_controller/state_controller_test.cc
@@ -104,8 +104,12 @@ struct HmiStatesIDComparator {
 #define NAVI true
 #define NOT_NAVI false
 
-
-enum ApplicationType {APP_TYPE_NON_MEDIA, APP_TYPE_NAVI, APP_TYPE_MEDIA, APPTYPE_ATTENUATED};
+enum ApplicationType {
+  APP_TYPE_NON_MEDIA,
+  APP_TYPE_NAVI,
+  APP_TYPE_MEDIA,
+  APPTYPE_ATTENUATED
+};
 
 class StateControllerTest : public ::testing::Test {
  public:
@@ -164,10 +168,9 @@ class StateControllerTest : public ::testing::Test {
   std::vector<HmiStatePtr> invalid_states_for_audio_app;
   std::vector<HmiState::StateID> valid_state_ids_;
   std::vector<am::ApplicationSharedPtr> applications_list_;
-  HmiStatePtr createHmiState(
-      mobile_apis::HMILevel::eType hmi_level,
-      mobile_apis::AudioStreamingState::eType aidio_ss,
-      mobile_apis::SystemContext::eType system_context) {
+  HmiStatePtr createHmiState(mobile_apis::HMILevel::eType hmi_level,
+                             mobile_apis::AudioStreamingState::eType aidio_ss,
+                             mobile_apis::SystemContext::eType system_context) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -180,13 +183,11 @@ class StateControllerTest : public ::testing::Test {
     return state;
   }
 
-
   /**
    * @brief Prepare list of resultant HMI states for testing HMIState
    * @param result_hmi state will contain resultant HMI states.
    */
-  void PrepareCommonStateResults(
-      std::vector<HmiStatePtr>& result_hmi_state) {
+  void PrepareCommonStateResults(std::vector<HmiStatePtr>& result_hmi_state) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -194,13 +195,15 @@ class StateControllerTest : public ::testing::Test {
                                               AudioStreamingState::NOT_AUDIBLE,
                                               SystemContext::SYSCTXT_MAIN));
     result_hmi_state.push_back(
-        createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE,
+        createHmiState(HMILevel::HMI_NONE,
+                       AudioStreamingState::NOT_AUDIBLE,
                        SystemContext::SYSCTXT_VRSESSION));
     result_hmi_state.push_back(createHmiState(HMILevel::HMI_NONE,
                                               AudioStreamingState::NOT_AUDIBLE,
                                               SystemContext::SYSCTXT_MENU));
     result_hmi_state.push_back(
-        createHmiState(HMILevel::HMI_NONE, AudioStreamingState::NOT_AUDIBLE,
+        createHmiState(HMILevel::HMI_NONE,
+                       AudioStreamingState::NOT_AUDIBLE,
                        SystemContext::SYSCTXT_HMI_OBSCURED));
     result_hmi_state.push_back(createHmiState(HMILevel::HMI_NONE,
                                               AudioStreamingState::NOT_AUDIBLE,
@@ -249,49 +252,50 @@ class StateControllerTest : public ::testing::Test {
     switch (app_t) {
       case APP_TYPE_NON_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
-        result_hmi_state.push_back(createHmiState(
-            HMILevel::HMI_BACKGROUND, AudioStreamingState::NOT_AUDIBLE,
-            SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_BACKGROUND,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
         break;
       }
       case APP_TYPE_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_BACKGROUND,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_BACKGROUND,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_BACKGROUND,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_BACKGROUND,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_BACKGROUND,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_BACKGROUND,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_BACKGROUND,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_BACKGROUND,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
         break;
       }
       case APP_TYPE_NAVI: {
         PrepareCommonStateResults(result_hmi_state);
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_LIMITED,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_LIMITED,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_LIMITED,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-                                     HMILevel::HMI_LIMITED,
-                                     AudioStreamingState::NOT_AUDIBLE,
-                                     SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
         break;
       }
       default: { break; }
@@ -303,8 +307,8 @@ class StateControllerTest : public ::testing::Test {
    * case if VR or TTS mode is active
    * @param result_hmi state will contain resultant HMI states.
    */
-  void PrepareVRTTSHMIStateResults(
-      std::vector<HmiStatePtr>& result_hmi_state, ApplicationType app_t) {
+  void PrepareVRTTSHMIStateResults(std::vector<HmiStatePtr>& result_hmi_state,
+                                   ApplicationType app_t) {
     namespace HMILevel = mobile_apis::HMILevel;
     namespace AudioStreamingState = mobile_apis::AudioStreamingState;
     namespace SystemContext = mobile_apis::SystemContext;
@@ -312,24 +316,29 @@ class StateControllerTest : public ::testing::Test {
       case APP_TYPE_NON_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
       case APP_TYPE_MEDIA:
       case APP_TYPE_NAVI: {
         PrepareCommonStateResults(result_hmi_state);
-        result_hmi_state.push_back(createHmiState(
-            HMILevel::HMI_LIMITED, AudioStreamingState::NOT_AUDIBLE,
-            SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-            HMILevel::HMI_LIMITED, AudioStreamingState::NOT_AUDIBLE,
-            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
@@ -355,23 +364,28 @@ class StateControllerTest : public ::testing::Test {
       case APP_TYPE_NON_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
       case APP_TYPE_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
-        result_hmi_state.push_back(createHmiState(
-            HMILevel::HMI_LIMITED, AudioStreamingState::NOT_AUDIBLE,
-            SystemContext::SYSCTXT_MAIN));
-        result_hmi_state.push_back(createHmiState(
-            HMILevel::HMI_LIMITED, AudioStreamingState::ATTENUATED,
-            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_LIMITED,
+                           AudioStreamingState::ATTENUATED,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
+                           SystemContext::SYSCTXT_MAIN));
+        result_hmi_state.push_back(
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
@@ -398,7 +412,8 @@ class StateControllerTest : public ::testing::Test {
       case APP_TYPE_NON_MEDIA: {
         PrepareCommonStateResults(result_hmi_state);
         result_hmi_state.push_back(
-            createHmiState(HMILevel::HMI_FULL, AudioStreamingState::NOT_AUDIBLE,
+            createHmiState(HMILevel::HMI_FULL,
+                           AudioStreamingState::NOT_AUDIBLE,
                            SystemContext::SYSCTXT_MAIN));
         break;
       }
@@ -424,7 +439,8 @@ class StateControllerTest : public ::testing::Test {
     return app_type;
   }
 
-  void TestSetState(am::ApplicationSharedPtr app, HmiStatePtr hmi_state,
+  void TestSetState(am::ApplicationSharedPtr app,
+                    HmiStatePtr hmi_state,
                     ApplicationType app_t,
                     void (StateControllerTest::*call_back)(
                         std::vector<HmiStatePtr>&, ApplicationType)) {
@@ -453,11 +469,12 @@ class StateControllerTest : public ::testing::Test {
     }
   }
 
-  void TestSetSeveralState(
-      am::ApplicationSharedPtr app, HmiStatePtr first_hmi_state,
-      HmiStatePtr second_hmi_state, ApplicationType app_t,
-      void (StateControllerTest::*call_back)(std::vector<HmiStatePtr>&,
-                                             ApplicationType)) {
+  void TestSetSeveralState(am::ApplicationSharedPtr app,
+                           HmiStatePtr first_hmi_state,
+                           HmiStatePtr second_hmi_state,
+                           ApplicationType app_t,
+                           void (StateControllerTest::*call_back)(
+                               std::vector<HmiStatePtr>&, ApplicationType)) {
     InsertApplication(app);
     std::vector<HmiStatePtr> result_hmi_state;
     (this->*call_back)(result_hmi_state, app_t);
@@ -502,10 +519,10 @@ class StateControllerTest : public ::testing::Test {
           utils::MakeShared<T>(app_id, &app_manager_mock_);
       HmiStatePtr state_second =
           utils::MakeShared<Q>(app_id, &app_manager_mock_);
-      TestSetSeveralState(app, state_first, state_second, app_type,
-                          call_back_result);
-      TestSetSeveralState(app, state_second, state_first, app_type,
-                          call_back_result);
+      TestSetSeveralState(
+          app, state_first, state_second, app_type, call_back_result);
+      TestSetSeveralState(
+          app, state_second, state_first, app_type, call_back_result);
     }
   }
 
@@ -919,7 +936,7 @@ class StateControllerTest : public ::testing::Test {
       EXPECT_CALL(application, RemoveHMIState(state_id)).Times(1);
 
       EXPECT_CALL(application, PostponedHmiState())
-                .WillOnce(Return(NoneNotAudibleState()));
+          .WillOnce(Return(NoneNotAudibleState()));
       EXPECT_CALL(application, RemovePostponedState());
 
       switch (state_id) {
@@ -1112,8 +1129,6 @@ TEST_F(StateControllerTest, MoveAppFromValidStateToInvalid) {
 }
 
 TEST_F(StateControllerTest, SetFullToSimpleAppWhileAnotherSimpleAppIsInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1192,8 +1207,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1220,8 +1233,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetFullToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1249,8 +1260,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetLimitedToAudioAppAppWhileSameTypeAudioAppAppIsInLimited) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1278,8 +1287,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInLimited) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1303,8 +1310,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetLimitedToAudioAppAppWhileOtherTypeAudioAppAppIsInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1328,8 +1333,6 @@ TEST_F(StateControllerTest,
 }
 
 TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1362,8 +1365,6 @@ TEST_F(StateControllerTest, SetFullToSimpleAppWhile2AudioAppsInLimited) {
 
 TEST_F(StateControllerTest,
        SetFullToSimpleAppWhile1AudioAppInLimitedAnd1AudioAppInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1397,8 +1398,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetFullToSimpleAppWhile1AudioAppInLimitedAnd1SimpleAppInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1435,8 +1434,6 @@ TEST_F(StateControllerTest,
 TEST_F(
     StateControllerTest,
     SetFullToAudioAppWhile1AudioAppWithSameTypeInLimitedAnd1SimpleAppInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1474,8 +1471,6 @@ TEST_F(
 TEST_F(
     StateControllerTest,
     SetFullToAudioAppWhileAudioAppWithSameTypeInLimitedAndAudioAppWithOtherTypeInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1512,8 +1507,6 @@ TEST_F(
 
 TEST_F(StateControllerTest,
        SetFullToAudioAppWhile3AudioAppsWithSameTypeInLimited) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1537,8 +1530,6 @@ TEST_F(StateControllerTest,
 
 TEST_F(StateControllerTest,
        SetFullToAudioAppWhile2AudioAppsWithSameTypeInLimitedAndOneInFull) {
-
-
   namespace HMILevel = mobile_apis::HMILevel;
   namespace AudioStreamingState = mobile_apis::AudioStreamingState;
   namespace SystemContext = mobile_apis::SystemContext;
@@ -1678,46 +1669,57 @@ TEST_F(StateControllerTest, ApplyTempStatesForMediaNaviVCApp) {
   CheckStateApplyingForApplication(*media_navi_vc_app_ptr_, valid_state_ids_);
 }
 
-
 TEST_F(StateControllerTest, SetStatePhoneCallForNonMediaApplication) {
   HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       simple_app_id_, &app_manager_mock_);
-  TestSetState(simple_app_, state_phone_call, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_phone_call,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PreparePhoneCallHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetStatePhoneCallForMediaApplication) {
   HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       media_app_id_, &app_manager_mock_);
-  TestSetState(media_app_, state_phone_call, APP_TYPE_MEDIA,
+  TestSetState(media_app_,
+               state_phone_call,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PreparePhoneCallHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetStatePhoneCallForMediaNaviApplication) {
   HmiStatePtr state_phone_call = utils::MakeShared<am::PhoneCallHmiState>(
       media_navi_app_id_, &app_manager_mock_);
-  TestSetState(media_navi_app_, state_phone_call, APP_TYPE_NAVI,
+  TestSetState(media_navi_app_,
+               state_phone_call,
+               APP_TYPE_NAVI,
                &StateControllerTest::PreparePhoneCallHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetVRStateForNonMediaApplication) {
   HmiStatePtr state_vr =
       utils::MakeShared<am::VRHmiState>(simple_app_id_, &app_manager_mock_);
-  TestSetState(simple_app_, state_vr, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_vr,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetVRStateForMediaApplication) {
   HmiStatePtr state_vr =
       utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
-  TestSetState(media_app_, state_vr, APP_TYPE_MEDIA,
+  TestSetState(media_app_,
+               state_vr,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetVRStateForMediaNaviVoiceApplication) {
   HmiStatePtr state_vr = utils::MakeShared<am::VRHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
-  TestSetState(media_navi_vc_app_, state_vr, APP_TYPE_MEDIA,
+  TestSetState(media_navi_vc_app_,
+               state_vr,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1727,7 +1729,9 @@ TEST_F(StateControllerTest,
       utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
-  TestSetState(simple_app_, state_tts, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_tts,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1737,7 +1741,9 @@ TEST_F(StateControllerTest,
       utils::MakeShared<am::TTSHmiState>(simple_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
-  TestSetState(simple_app_, state_tts, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_tts,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1747,7 +1753,9 @@ TEST_F(StateControllerTest,
       utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
-  TestSetState(media_app_, state_tts, APP_TYPE_MEDIA,
+  TestSetState(media_app_,
+               state_tts,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1756,7 +1764,9 @@ TEST_F(StateControllerTest, SetTTSStateForMediaApplicationAttenuatedSupported) {
       utils::MakeShared<am::TTSHmiState>(media_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
-  TestSetState(media_app_, state_tts, APPTYPE_ATTENUATED,
+  TestSetState(media_app_,
+               state_tts,
+               APPTYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1766,7 +1776,9 @@ TEST_F(StateControllerTest,
       media_navi_vc_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
-  TestSetState(media_navi_vc_app_, state_tts, APP_TYPE_MEDIA,
+  TestSetState(media_navi_vc_app_,
+               state_tts,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1776,7 +1788,9 @@ TEST_F(StateControllerTest,
       media_navi_vc_app_id_, &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
-  TestSetState(media_navi_vc_app_, state_tts, APPTYPE_ATTENUATED,
+  TestSetState(media_navi_vc_app_,
+               state_tts,
+               APPTYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1784,7 +1798,9 @@ TEST_F(StateControllerTest, SetNaviStreamingStateForNonMediaApplication) {
   HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(simple_app_id_,
                                                    &app_manager_mock_);
-  TestSetState(simple_app_, state_navi_streming, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_navi_streming,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PrepareNaviStreamingHMIStateResults);
 }
 
@@ -1795,7 +1811,9 @@ TEST_F(StateControllerTest,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
-  TestSetState(media_app_, state_navi_streming, APP_TYPE_MEDIA,
+  TestSetState(media_app_,
+               state_navi_streming,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareNaviStreamingHMIStateResults);
 }
 
@@ -1806,7 +1824,9 @@ TEST_F(StateControllerTest,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
-  TestSetState(media_app_, state_navi_streming, APPTYPE_ATTENUATED,
+  TestSetState(media_app_,
+               state_navi_streming,
+               APPTYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1817,7 +1837,9 @@ TEST_F(StateControllerTest,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(false));
-  TestSetState(vc_app_, state_navi_streming, APP_TYPE_MEDIA,
+  TestSetState(vc_app_,
+               state_navi_streming,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareNaviStreamingHMIStateResults);
 }
 
@@ -1828,7 +1850,9 @@ TEST_F(StateControllerTest,
                                                    &app_manager_mock_);
   EXPECT_CALL(app_manager_mock_, is_attenuated_supported())
       .WillRepeatedly(Return(true));
-  TestSetState(vc_app_, state_navi_streming, APPTYPE_ATTENUATED,
+  TestSetState(vc_app_,
+               state_navi_streming,
+               APPTYPE_ATTENUATED,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -1836,7 +1860,9 @@ TEST_F(StateControllerTest, SetNaviStreamingStateNaviApplication) {
   HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(navi_app_id_,
                                                    &app_manager_mock_);
-  TestSetState(navi_app_, state_navi_streming, APP_TYPE_NAVI,
+  TestSetState(navi_app_,
+               state_navi_streming,
+               APP_TYPE_NAVI,
                &StateControllerTest::PrepareNaviStreamingHMIStateResults);
 }
 
@@ -1844,28 +1870,36 @@ TEST_F(StateControllerTest, SetNaviStreamingStateMediaNaviApplication) {
   HmiStatePtr state_navi_streming =
       utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_id_,
                                                    &app_manager_mock_);
-  TestSetState(media_navi_app_, state_navi_streming, APP_TYPE_NAVI,
+  TestSetState(media_navi_app_,
+               state_navi_streming,
+               APP_TYPE_NAVI,
                &StateControllerTest::PrepareNaviStreamingHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForNonMediaApplication) {
   HmiStatePtr state_safety_mode = utils::MakeShared<am::SafetyModeHmiState>(
       simple_app_id_, &app_manager_mock_);
-  TestSetState(simple_app_, state_safety_mode, APP_TYPE_NON_MEDIA,
+  TestSetState(simple_app_,
+               state_safety_mode,
+               APP_TYPE_NON_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForMediaApplication) {
   HmiStatePtr state_safety_mode =
       utils::MakeShared<am::VRHmiState>(media_app_id_, &app_manager_mock_);
-  TestSetState(media_app_, state_safety_mode, APP_TYPE_MEDIA,
+  TestSetState(media_app_,
+               state_safety_mode,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
 TEST_F(StateControllerTest, SetSafetyModeStateForMediaNaviVoiceApplication) {
   HmiStatePtr state_safety_mode = utils::MakeShared<am::VRHmiState>(
       media_navi_vc_app_id_, &app_manager_mock_);
-  TestSetState(media_navi_vc_app_, state_safety_mode, APP_TYPE_MEDIA,
+  TestSetState(media_navi_vc_app_,
+               state_safety_mode,
+               APP_TYPE_MEDIA,
                &StateControllerTest::PrepareVRTTSHMIStateResults);
 }
 
@@ -2028,7 +2062,8 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
   EXPECT_CALL(*message_helper_mock_,
               SendActivateAppToHMI(
                   simple_app_->app_id(),
-                  static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl), _))
+                  static_cast<hmi_apis::Common_HMILevel::eType>(set_lvl),
+                  _))
       .WillOnce(Return(corr_id));
 
   state_ctrl_.SetRegularState(simple_app_, set_lvl);
@@ -2047,9 +2082,9 @@ TEST_F(StateControllerTest, SetRegularStateWithNewHmiLvl) {
 TEST_F(StateControllerTest, SetRegularStateWithAudioStateAudible) {
   using namespace mobile_apis;
 
-  HmiStatePtr check_state =
-      createHmiState(HMILevel::HMI_BACKGROUND, AudioStreamingState::AUDIBLE,
-                     SystemContext::SYSCTXT_MAIN);
+  HmiStatePtr check_state = createHmiState(HMILevel::HMI_BACKGROUND,
+                                           AudioStreamingState::AUDIBLE,
+                                           SystemContext::SYSCTXT_MAIN);
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState())
       .WillRepeatedly(Return(BackgroundState()));
 
@@ -2073,8 +2108,7 @@ TEST_F(StateControllerTest,
   HmiStatePtr check_state = FullNotAudibleState();
 
   // Non-media app can't have LIMITED-AUDIO state
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0);
   EXPECT_CALL(*simple_app_ptr_, SetRegularState(_)).Times(0);
   EXPECT_CALL(app_manager_mock_, GetDefaultHmiLevel(_))
@@ -2086,8 +2120,7 @@ TEST_F(StateControllerTest,
   state_ctrl_.SetRegularState<false>(simple_app_, check_state);
 
   check_state = LimitedState();
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
   EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0);
   EXPECT_CALL(*media_app_ptr_, SetRegularState(_)).Times(0);
   EXPECT_CALL(*media_app_ptr_,
@@ -2113,11 +2146,11 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
       .WillOnce(Return(check_state))
       .WillOnce(Return(check_state));
 
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(*message_helper_mock_,
-              SendOnResumeAudioSourceToHMI(simple_app_id_)).Times(0);
+              SendOnResumeAudioSourceToHMI(simple_app_id_))
+      .Times(0);
   EXPECT_CALL(*simple_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))))
       .Times(0);
@@ -2132,8 +2165,7 @@ TEST_F(StateControllerTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
       .WillOnce(Return(check_state))
       .WillOnce(Return(check_state));
 
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*message_helper_mock_,
               SendOnResumeAudioSourceToHMI(media_app_id_));
@@ -2161,8 +2193,7 @@ TEST_F(StateControllerTest,
 
   // Non-media app can't have LIMITED-AUDIO state
   HmiStatePtr check_state = FullNotAudibleState();
-  EXPECT_CALL(*simple_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*simple_app_ptr_, RegularHmiState()).Times(0);
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState()).Times(0);
@@ -2177,8 +2208,7 @@ TEST_F(StateControllerTest,
 
   // Set media app
   check_state = LimitedState();
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*media_app_ptr_, RegularHmiState()).Times(0);
   EXPECT_CALL(*media_app_ptr_, CurrentHmiState()).Times(0);
@@ -2200,23 +2230,21 @@ TEST_F(StateControllerTest,
   SmartObject message;
   message[am::strings::msg_params][am::hmi_notification::is_active] = true;
 
-
   event.set_smart_object(message);
   state_ctrl_.on_event(event);
 
   HmiStatePtr check_state = FullAudibleState();
 
-  EXPECT_CALL(*media_app_ptr_, is_resuming())
-      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*media_app_ptr_, is_resuming()).WillRepeatedly(Return(true));
 
   EXPECT_CALL(*media_app_ptr_, is_media_application())
       .WillRepeatedly(Return(true));
 
   EXPECT_CALL(app_manager_mock_, IsAppTypeExistsInFullOrLimited(_))
-              .WillRepeatedly(Return(false));
+      .WillRepeatedly(Return(false));
 
   EXPECT_CALL(app_manager_mock_, active_application())
-              .WillRepeatedly(Return(am::ApplicationSharedPtr()));
+      .WillRepeatedly(Return(am::ApplicationSharedPtr()));
 
   EXPECT_CALL(*media_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))));